244 files changed, 124499 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..98593594
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,21 @@
+*~
+*.tar.bz2
+*.tar.gz
+aclocal.m4
+autom4te.cache
+compile
+config.guess
+config.h
+config.h.in
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+missing
+Makefile
+Makefile.in
+stamp-h1
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/AUTHORS
diff --git a/COPYING b/COPYING
new file mode 100644
index 00000000..08ddefd0
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 of the License, 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, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/ChangeLog
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 00000000..c5e5c7bb
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,7 @@
+SUBDIRS = common server client
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = spice.pc
+
+DISTCLEANFILES =                                \
+	spice.pc
diff --git a/NEWS b/NEWS
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/NEWS
diff --git a/README b/README
new file mode 100644
index 00000000..b55a2225
--- /dev/null
+++ b/README
@@ -0,0 +1,10 @@
+Copyright 2009 Red Hat, Inc. and/or its affiliates.  
+
+This program is licensed to you under the GNU General Public License,
+version 2 or (at your option) any later version published by the Free
+Software Foundation.  See the file COPYING for details.
+
+There is NO WARRANTY for this software, not even the implied
+warranties of MERCHANTABILITY, NONINFRINGEMENT, or FITNESS FOR A
+PARTICULAR PURPOSE.
+
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 00000000..9bba4d7e
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,170 @@
+#! /bin/sh
+
+srcdir=`dirname $0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd $srcdir
+
+# FIXME: can replace this entire script with
+# the following line if we can require autoconf 2.60:
+# autoreconf -v --force --install || exit 1
+
+PACKAGE=spice
+
+ACLOCAL_FLAGS=""
+LIBTOOLIZE=${LIBTOOLIZE-libtoolize}
+LIBTOOLIZE_FLAGS="--copy --force"
+AUTOHEADER=${AUTOHEADER-autoheader}
+AUTOMAKE_FLAGS="--add-missing --gnu"
+AUTOCONF=${AUTOCONF-autoconf}
+
+# automake 1.8 requires autoconf 2.58
+# automake 1.7 requires autoconf 2.54
+automake_min_vers=1.7
+aclocal_min_vers=$automake_min_vers
+autoconf_min_vers=2.54
+libtoolize_min_vers=1.4
+
+# The awk-based string->number conversion we use needs a C locale to work
+# as expected. Setting LC_ALL overrides whether the user set LC_ALL,
+# LC_NUMERIC, or LANG.
+LC_ALL=C
+
+ARGV0=$0
+
+# Allow invocation from a separate build directory; in that case, we change
+# to the source directory to run the auto*, then change back before running configure
+srcdir=`dirname $ARGV0`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+
+# Not all echo versions allow -n, so we check what is possible. This test is
+# based on the one in autoconf.
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+  *c*,-n*) ECHO_N= ;;
+  *c*,*  ) ECHO_N=-n ;;
+  *)       ECHO_N= ;;
+esac
+
+
+# some terminal codes ...
+boldface="`tput bold 2>/dev/null || true`"
+normal="`tput sgr0 2>/dev/null || true`"
+printbold() {
+    echo $ECHO_N "$boldface"
+    echo "$@"
+    echo $ECHO_N "$normal"
+}
+printerr() {
+    echo "$@" >&2
+}
+
+
+# Usage:
+#     compare_versions MIN_VERSION ACTUAL_VERSION
+# returns true if ACTUAL_VERSION >= MIN_VERSION
+compare_versions() {
+    ch_min_version=$1
+    ch_actual_version=$2
+    ch_status=0
+    IFS="${IFS=         }"; ch_save_IFS="$IFS"; IFS="."
+    set $ch_actual_version
+    for ch_min in $ch_min_version; do
+        ch_cur=`echo $1 | sed 's/[^0-9].*$//'`; shift # remove letter suffixes
+        if [ -z "$ch_min" ]; then break; fi
+        if [ -z "$ch_cur" ]; then ch_status=1; break; fi
+        if [ $ch_cur -gt $ch_min ]; then break; fi
+        if [ $ch_cur -lt $ch_min ]; then ch_status=1; break; fi
+    done
+    IFS="$ch_save_IFS"
+    return $ch_status
+}
+
+# Usage:
+#     version_check PACKAGE VARIABLE CHECKPROGS MIN_VERSION SOURCE
+# checks to see if the package is available
+version_check() {
+    vc_package=$1
+    vc_variable=$2
+    vc_checkprogs=$3
+    vc_min_version=$4
+    vc_source=$5
+    vc_status=1
+
+    vc_checkprog=`eval echo "\\$$vc_variable"`
+    if [ -n "$vc_checkprog" ]; then
+	printbold "using $vc_checkprog for $vc_package"
+	return 0
+    fi
+
+    printbold "checking for $vc_package >= $vc_min_version..."
+    for vc_checkprog in $vc_checkprogs; do
+	echo $ECHO_N "  testing $vc_checkprog... "
+	if $vc_checkprog --version < /dev/null > /dev/null 2>&1; then
+	    vc_actual_version=`$vc_checkprog --version | head -n 1 | \
+                               sed 's/^.*[ 	]\([0-9.]*[a-z]*\).*$/\1/'`
+	    if compare_versions $vc_min_version $vc_actual_version; then
+		echo "found $vc_actual_version"
+		# set variable
+		eval "$vc_variable=$vc_checkprog"
+		vc_status=0
+		break
+	    else
+		echo "too old (found version $vc_actual_version)"
+	    fi
+	else
+	    echo "not found."
+	fi
+    done
+    if [ "$vc_status" != 0 ]; then
+	printerr "***Error***: You must have $vc_package >= $vc_min_version installed"
+	printerr "  to build $PROJECT.  Download the appropriate package for"
+	printerr "  from your distribution or get the source tarball at"
+        printerr "    $vc_source"
+	printerr
+    fi
+    return $vc_status
+}
+
+version_check autoconf AUTOCONF $AUTOCONF $autoconf_min_vers \
+    "http://ftp.gnu.org/pub/gnu/autoconf/autoconf-${autoconf_min_vers}.tar.gz" || DIE=1
+version_check automake AUTOMAKE "$AUTOMAKE automake automake-1.10 automake-1.9 automake-1.8 automake-1.7" $automake_min_vers \
+    "http://ftp.gnu.org/pub/gnu/automake/automake-${automake_min_vers}.tar.gz" || DIE=1
+ACLOCAL=`echo $AUTOMAKE | sed s/automake/aclocal/`
+version_check libtool LIBTOOLIZE "$LIBTOOLIZE glibtoolize libtoolize" $libtoolize_min_vers \
+    "http://ftp.gnu.org/pub/gnu/libtool/libtool-${libtool_min_vers}.tar.gz" || DIE=1
+
+if test -n "$DIE"; then
+  exit 1
+fi
+
+
+if test -z "$*"; then
+  echo "$ARGV0:	Note: \`./configure' will be run with no arguments."
+  echo "		If you wish to pass any to it, please specify them on the"
+  echo "		\`$0' command line."
+  echo
+fi
+
+do_cmd() {
+    echo "$ARGV0: running \`$@'"
+    $@
+}
+
+# Run for top level directory
+
+printbold "Setting up $PACKAGE toplevel"
+cd $srcdir
+do_cmd $LIBTOOLIZE $LIBTOOLIZE_FLAGS
+do_cmd $ACLOCAL $ACLOCAL_FLAGS
+do_cmd $AUTOHEADER
+do_cmd $AUTOMAKE $AUTOMAKE_FLAGS
+do_cmd $AUTOCONF
+
+cd $ORIGDIR || exit $?
+rm -f config.cache
+
+do_cmd $srcdir/configure --enable-maintainer-mode ${1+"$@"} || exit 1
+
diff --git a/client/.gitignore b/client/.gitignore
new file mode 100644
index 00000000..07491dd4
--- /dev/null
+++ b/client/.gitignore
@@ -0,0 +1,8 @@
+*.la
+*.lo
+*.loT
+*.o
+.deps
+.libs
+Makefile
+Makefile.in
diff --git a/client/Makefile.am b/client/Makefile.am
new file mode 100644
index 00000000..bb78ba49
--- /dev/null
+++ b/client/Makefile.am
@@ -0,0 +1,82 @@
+NULL =
+
+SUBDIRS = $(red_target)
+DIST_SUBDIRS = x11 #windows
+
+RED_COMMON_SRCS =	 		\
+	application.cpp			\
+	application.h			\
+	audio_channels.h		\
+	audio_devices.h			\
+	cache.hpp			\
+	cairo_canvas.cpp		\
+	canvas.cpp			\
+	canvas.h			\
+	canvas_utils.cpp		\
+	red_cairo_canvas.cpp		\
+	red_cairo_canvas.h		\
+	cmd_line_parser.cpp		\
+	cmd_line_parser.h		\
+	common.h			\
+	cursor_channel.cpp		\
+	cursor_channel.h		\
+	cursor.cpp			\
+	cursor.h			\
+	debug.h				\
+	display_channel.cpp		\
+	display_channel.h		\
+	events_loop.h			\
+	red_gl_canvas.cpp		\
+	red_gl_canvas.h			\
+	gl_canvas.cpp			\
+	glc.cpp				\
+	glz_decoded_image.h		\
+	glz_decoder_config.h		\
+	glz_decoder.cpp			\
+	glz_decoder.h			\
+	glz_decoder_window.cpp		\
+	glz_decoder_window.h		\
+	glz_decode_tmpl.c		\
+	inputs_channel.cpp		\
+	inputs_channel.h		\
+	inputs_handler.h		\
+	lz.cpp				\
+	monitor.cpp			\
+	monitor.h			\
+	menu.cpp			\
+	menu.h				\
+	pixels_source.h			\
+	platform.h			\
+	playback_channel.cpp		\
+	quic.cpp			\
+	read_write_mutex.h		\
+	record_channel.cpp		\
+	red_channel.cpp			\
+	red_channel.h			\
+	red_client.cpp			\
+	red_client.h			\
+	red_drawable.h			\
+	red_key.h			\
+	red_peer.cpp			\
+	red_peer.h			\
+	red_pixmap_cairo.h		\
+	red_pixmap_gl.h			\
+	red_pixmap.h			\
+	red_types.h			\
+	red_window.h			\
+	region.cpp			\
+	rop3.cpp			\
+	screen.cpp			\
+	screen.h			\
+	screen_layer.cpp		\
+	screen_layer.h			\
+	shared_cache.hpp		\
+	hot_keys.cpp			\
+	hot_keys.h			\
+        threads.cpp			\
+        threads.h			\
+	utils.cpp			\
+	utils.h				\
+	$(NULL)
+
+EXTRA_DIST = $(RED_COMMON_SRCS)
diff --git a/client/application.cpp b/client/application.cpp
new file mode 100644
index 00000000..b30baa84
--- /dev/null
+++ b/client/application.cpp
@@ -0,0 +1,1674 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef WIN32
+#include "config.h"
+#endif
+
+#include "common.h"
+#ifdef WIN32
+#include <io.h>
+#endif
+
+#include "application.h"
+#include "screen.h"
+#include "utils.h"
+#include "debug.h"
+#include "screen_layer.h"
+#include "monitor.h"
+#include "resource.h"
+#ifdef WIN32
+#include "red_gdi_canvas.h"
+#endif
+#include "platform.h"
+#include "cairo_canvas.h"
+#include "gl_canvas.h"
+#include "quic.h"
+#include "mutex.h"
+#include "cmd_line_parser.h"
+
+#include <log4cpp/BasicConfigurator.hh>
+#include <log4cpp/FileAppender.hh>
+#include <log4cpp/RollingFileAppender.hh>
+
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+mutex_t cairo_surface_user_data_mutex;
+#endif
+
+SyncEvent::SyncEvent()
+    : _err (false)
+    , _ready (false)
+{
+}
+
+SyncEvent::~SyncEvent()
+{
+}
+
+void SyncEvent::responce(Application& application)
+{
+    try {
+        do_responce(application);
+    } catch (Exception& e) {
+        LOG_WARN("unhandle exception: %s", e.what());
+        _err = true;
+    } catch (...) {
+        _err = true;
+    }
+    Lock lock(_mutex);
+    _ready = true;
+    _condition.notify_one();
+}
+
+void SyncEvent::wait()
+{
+    //todo: process event if on main thread
+    Lock lock(_mutex);
+    while (!_ready) {
+        _condition.wait(lock);
+    }
+}
+
+void ConnectedEvent::responce(Application& application)
+{
+    application.on_connected();
+}
+
+void DisconnectedEvent::responce(Application& application)
+{
+    application.show_splash(0);
+#ifndef RED_DEBUG
+    application.quit(SPICEC_ERROR_CODE_SUCCESS);
+#endif
+}
+
+void CoonnectionError::responce(Application& application)
+{
+    application.show_splash(0);
+#ifndef RED_DEBUG
+    application.quit(_error_code);
+#endif
+}
+
+void ErrorEvent::responce(Application& application)
+{
+    application.quit(SPICEC_ERROR_CODE_ERROR);
+}
+
+void MonitorsQuery::do_responce(Application& application)
+{
+    Monitor* mon;
+    int i = 0;
+
+    while ((mon = application.find_monitor(i++))) {
+        MonitorInfo info;
+        info.size = mon->get_size();
+        info.depth = 32;
+        info.position = mon->get_position();
+        _monitors.push_back(info);
+    }
+}
+
+class GUILayer: public ScreenLayer {
+public:
+    GUILayer();
+
+    virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc);
+
+    void set_splash_mode();
+    void set_info_mode();
+    virtual void on_size_changed();
+
+private:
+    void draw_splash(const QRegion& dest_region, RedDrawable& dest);
+    void draw_info(const QRegion& dest_region, RedDrawable& dest);
+
+private:
+    ImageFromRes _splash_pixmap;
+    AlphaImageFromRes _info_pixmap;
+    Point _splash_pos;
+    Point _info_pos;
+    bool _splash_mode;
+    Mutex _update_lock;
+};
+
+GUILayer::GUILayer()
+    : ScreenLayer(SCREEN_LAYER_GUI, false)
+    , _splash_pixmap (SPLASH_IMAGE_RES_ID)
+    , _info_pixmap (INFO_IMAGE_RES_ID)
+    , _splash_mode (false)
+{
+}
+
+void GUILayer::draw_splash(const QRegion& dest_region, RedDrawable& dest)
+{
+    for (int i = 0; i < (int)dest_region.num_rects; i++) {
+        Rect* r = &dest_region.rects[i];
+        dest.copy_pixels(_splash_pixmap, r->left - _splash_pos.x, r->top - _splash_pos.y, *r);
+    }
+}
+
+void GUILayer::draw_info(const QRegion& dest_region, RedDrawable& dest)
+{
+    for (int i = 0; i < (int)dest_region.num_rects; i++) {
+        Rect* r = &dest_region.rects[i];
+        dest.blend_pixels(_info_pixmap, r->left - _info_pos.x, r->top - _info_pos.y, *r);
+    }
+}
+
+void GUILayer::copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc)
+{
+    Lock lock(_update_lock);
+    if (_splash_mode) {
+        draw_splash(dest_region, dest_dc);
+    } else {
+        draw_info(dest_region, dest_dc);
+    }
+}
+
+void GUILayer::set_splash_mode()
+{
+    Lock lock(_update_lock);
+    Point size = _splash_pixmap.get_size();
+    Point screen_size = screen()->get_size();
+    Rect r;
+
+    _splash_pos.y = r.top = (screen_size.y - size.y) / 2;
+    _splash_pos.x = r.left = (screen_size.x - size.x) / 2;
+    r.bottom = r.top + size.y;
+    r.right = r.left + size.x;
+    _splash_mode = true;
+    lock.unlock();
+    set_rect_area(r);
+}
+
+void GUILayer::set_info_mode()
+{
+    Lock lock(_update_lock);
+    Point size = _info_pixmap.get_size();
+    Point screen_size = screen()->get_size();
+    Rect r;
+
+    r.left = (screen_size.x - size.x) / 2;
+    r.right = r.left + size.x;
+    _info_pos.x = r.right - size.x;
+    _info_pos.y = r.top = 0;
+    r.bottom = r.top + size.y;
+    _splash_mode = false;
+    lock.unlock();
+    set_rect_area(r);
+}
+
+void GUILayer::on_size_changed()
+{
+    set_info_mode();
+}
+
+static InputsHandler default_inputs_handler;
+
+enum AppCommands {
+    APP_CMD_INVALID,
+    APP_CMD_SEND_CTL_ALT_DEL,
+    APP_CMD_TOGGLE_FULL_SCREEN,
+    APP_CMD_RELEASE_CAPTURE,
+    APP_CMD_SEND_TOGGLE_KEYS,
+    APP_CMD_SEND_RELEASE_KEYS,
+    APP_CMD_SEND_CTL_ALT_END,
+#ifdef RED_DEBUG
+    APP_CMD_CONNECT,
+    APP_CMD_DISCONNECT,
+#endif
+};
+
+Application::Application()
+    : _client (*this)
+    , _enabled_channels(RED_CHANNEL_END, true)
+    , _main_screen (NULL)
+    , _quitting (false)
+    , _active (false)
+    , _full_screen (false)
+    , _changing_screens (false)
+    , _exit_code (0)
+    , _events_gen (0)
+    , _active_screen (NULL)
+    , _gui_layer (new GUILayer())
+    , _inputs_handler (&default_inputs_handler)
+    , _monitors (NULL)
+    , _title (L"SPICEc:%d")
+{
+    DBG(0, "");
+
+    init_monitors();
+    init_key_table();
+    init_menu();
+    _main_screen = get_screen(0);
+    _main_screen->attach_layer(*_gui_layer);
+    _gui_layer->set_splash_mode();
+
+    Platform::set_event_listener(this);
+    Platform::set_display_mode_listner(this);
+
+    _commands_map["toggle-fullscreen"] = APP_CMD_TOGGLE_FULL_SCREEN;
+    _commands_map["release-cursor"] = APP_CMD_RELEASE_CAPTURE;
+#ifdef RED_DEBUG
+    _commands_map["connect"] = APP_CMD_CONNECT;
+    _commands_map["disconnect"] = APP_CMD_DISCONNECT;
+#endif
+
+    _canvas_types.resize(1);
+#ifdef WIN32
+    _canvas_types[0] = CANVAS_OPTION_GDI;
+#else
+    _canvas_types[0] = CANVAS_OPTION_CAIRO;
+#endif
+
+    std::auto_ptr<HotKeysParser> parser(new HotKeysParser("toggle-fullscreen=shift+f11"
+                                                          ",release-cursor=shift+f12"
+#ifdef RED_DEBUG
+                                                          ",connect=shift+f5"
+                                                          ",disconnect=shift+f6"
+#endif
+                                                          , _commands_map));
+    _hot_keys = parser->get();
+}
+
+Application::~Application()
+{
+    _main_screen->detach_layer(*_gui_layer);
+    _main_screen->unref();
+    destroy_monitors();
+}
+
+void Application::init_menu()
+{
+    //fixme: menu items name need to be dynamically updated by hot keys configuration.
+    AutoRef<Menu> root_menu(new Menu(*this, ""));
+    (*root_menu)->add_command("Send Ctrl+Alt+Del\tCtrl+Alt+End", APP_CMD_SEND_CTL_ALT_DEL);
+    (*root_menu)->add_command("Toggle full screen\tShift+F11", APP_CMD_TOGGLE_FULL_SCREEN);
+    AutoRef<Menu> key_menu(new Menu(*this, "Special keys"));
+    (*key_menu)->add_command("Send Shift+F11", APP_CMD_SEND_TOGGLE_KEYS);
+    (*key_menu)->add_command("Send Shift+F12", APP_CMD_SEND_RELEASE_KEYS);
+    (*key_menu)->add_command("Send Ctrl+Alt+End", APP_CMD_SEND_CTL_ALT_END);
+    (*root_menu)->add_sub(key_menu.release());
+    _app_menu.reset(root_menu.release());
+}
+
+void Application::set_inputs_handler(InputsHandler& handler)
+{
+    unpress_all();
+    _inputs_handler = &handler;
+    if (_active) {
+        handler.on_focus_in();
+    }
+}
+
+void Application::remove_inputs_handler(InputsHandler& handler)
+{
+    if (_inputs_handler != &handler) {
+        return;
+    }
+    _inputs_handler = &default_inputs_handler;
+}
+
+void Application::process_events()
+{
+    _events_gen++;
+    for (;;) {
+        Event* event;
+        Lock lock(_events_lock);
+        if (_events.empty()) {
+            return;
+        }
+        event = _events.front();
+        if (event->_generation == _events_gen) {
+            Platform::wakeup();
+            return;
+        }
+        _events.pop_front();
+        lock.unlock();
+        event->responce(*this);
+        event->unref();
+    }
+}
+
+void Application::push_event(Event* event)
+{
+    Lock lock(_events_lock);
+    bool notify = _events.empty();
+    _events.push_back(event);
+    event->_generation = _events_gen;
+    event->ref();
+    if (notify) {
+        Platform::wakeup();
+    }
+}
+
+int Application::message_loop()
+{
+    for (;;) {
+        Platform::wait_events();
+        if (Platform::process_events()) {
+            _quitting = true;
+            break;
+        }
+        process_events();
+    }
+    return _exit_code;
+}
+
+void Application::abort()
+{
+    Platform::set_event_listener(NULL);
+    Platform::set_display_mode_listner(NULL);
+    unpress_all();
+    while (!_client.abort()) {
+        process_events();
+        Platform::msleep(100);
+    }
+}
+
+class AutoAbort {
+public:
+    AutoAbort(Application& app) : _app(app) {}
+    ~AutoAbort() { _app.abort();}
+
+private:
+    Application& _app;
+};
+
+void Application::connect()
+{
+    _client.connect();
+}
+
+int Application::run()
+{
+    try {
+        _client.connect();
+        _exit_code = message_loop();
+    } catch (...) {
+        throw;
+    }
+    return _exit_code;
+}
+
+void Application::quit(int exit_code)
+{
+    if (!_quitting) {
+        _quitting = true;
+        _exit_code = exit_code;
+        Platform::send_quit_request();
+    }
+}
+
+RedScreen* Application::find_screen(int id)
+{
+    if ((int)_screens.size() < id + 1) {
+        return NULL;
+    }
+    return _screens[id];
+}
+
+bool Application::release_capture()
+{
+    unpress_all();
+    if (!_active_screen || !_active_screen->is_captured()) {
+        return false;
+    }
+    _active_screen->relase_inputs();
+    return true;
+}
+
+bool Application::do_connect()
+{
+    _client.connect();
+    return true;
+}
+
+bool Application::do_disconnect()
+{
+    on_disconnecting();
+    _client.disconnect();
+    return true;
+}
+
+#define SCREEN_INIT_WIDTH 800
+#define SCREEN_INIT_HEIGHT 600
+
+RedScreen* Application::get_screen(int id)
+{
+    RedScreen *screen;
+
+    if ((int)_screens.size() < id + 1) {
+        _screens.resize(id + 1);
+    }
+
+    if (!(screen = _screens[id])) {
+        Monitor* mon;
+
+        if (_client.is_auto_display_res() && (mon = find_monitor(id))) {
+            Point size = mon->get_size();
+            screen = _screens[id] = new RedScreen(*this, id, _title, size.x, size.y);
+        } else {
+            screen = _screens[id] = new RedScreen(*this, id, _title, SCREEN_INIT_WIDTH,
+                                                  SCREEN_INIT_HEIGHT);
+        }
+        if (_full_screen) {
+            bool capture;
+
+            mon = get_monitor(id);
+            capture = release_capture();
+            screen->set_monitor(mon);
+            position_screens();
+            screen->show_full_screen();
+            prepare_monitors();
+
+            if (capture) {
+                _main_screen->activate();
+                _main_screen->capture_inputs();
+            }
+        } else if (id != 0) {
+            screen->show(false, _main_screen);
+        }
+    } else {
+        screen = screen->ref();
+    }
+
+    return screen;
+}
+
+void Application::on_screen_destroyed(int id, bool was_captured)
+{
+    bool reposition = false;
+
+    if ((int)_screens.size() < id + 1 || !_screens[id]) {
+        THROW("no screen");
+    }
+    if (_active_screen == _screens[id]) {
+        _active_screen = NULL;
+    }
+
+    if (_full_screen && _screens[id]->has_monitor()) {
+        _screens[id]->get_monitor()->restore();
+        reposition = true;
+    }
+    _screens[id] = NULL;
+    if (reposition) {
+        bool capture = was_captured || release_capture();
+        prepare_monitors();
+        position_screens();
+        if (capture) {
+            _main_screen->activate();
+            _main_screen->capture_inputs();
+        }
+    }
+}
+
+void Application::on_mouse_motion(int dx, int dy, int buttons_state)
+{
+    _inputs_handler->on_mouse_motion(dx, dy, buttons_state);
+}
+
+void Application::on_mouse_position(int x, int y, int buttons_state, int display_id)
+{
+    _inputs_handler->on_mouse_position(x, y, buttons_state, display_id);
+}
+
+void Application::on_mouse_down(int button, int buttons_state)
+{
+    _inputs_handler->on_mouse_down(button, buttons_state);
+}
+
+void Application::on_mouse_up(int button, int buttons_state)
+{
+    _inputs_handler->on_mouse_up(button, buttons_state);
+}
+
+void Application::init_scan_code(int index)
+{
+    ASSERT((index & 0x80) == 0);
+    _key_table[index]._make = index;
+    _key_table[index]._break = index | 0x80;
+}
+
+void Application::init_korean_scan_code(int index)
+{
+    _key_table[index]._make = index;
+    _key_table[index]._break = index;
+}
+
+void Application::init_escape_scan_code(int index)
+{
+    ASSERT(((index - REDKEY_ESCAPE_BASE) & 0x80) == 0);
+    _key_table[index]._make = 0xe0 | ((index - REDKEY_ESCAPE_BASE) << 8);
+    _key_table[index]._break = _key_table[index]._make | 0x8000;
+}
+
+void Application::init_pause_scan_code()
+{
+    _key_table[REDKEY_PAUSE]._make = 0x451de1;
+    _key_table[REDKEY_PAUSE]._break = 0xc59de1;
+}
+
+void Application::init_key_table()
+{
+    memset(_key_table, 0, sizeof(_key_table));
+    init_scan_code(REDKEY_ESCAPE);
+    init_scan_code(REDKEY_1);
+    init_scan_code(REDKEY_2);
+    init_scan_code(REDKEY_3);
+    init_scan_code(REDKEY_4);
+    init_scan_code(REDKEY_5);
+    init_scan_code(REDKEY_6);
+    init_scan_code(REDKEY_7);
+    init_scan_code(REDKEY_8);
+    init_scan_code(REDKEY_9);
+    init_scan_code(REDKEY_0);
+    init_scan_code(REDKEY_MINUS);
+    init_scan_code(REDKEY_EQUALS);
+    init_scan_code(REDKEY_BACKSPACE);
+    init_scan_code(REDKEY_TAB);
+    init_scan_code(REDKEY_Q);
+    init_scan_code(REDKEY_W);
+    init_scan_code(REDKEY_E);
+    init_scan_code(REDKEY_R);
+    init_scan_code(REDKEY_T);
+    init_scan_code(REDKEY_Y);
+    init_scan_code(REDKEY_U);
+    init_scan_code(REDKEY_I);
+    init_scan_code(REDKEY_O);
+    init_scan_code(REDKEY_P);
+    init_scan_code(REDKEY_L_BRACKET);
+    init_scan_code(REDKEY_R_BRACKET);
+    init_scan_code(REDKEY_ENTER);
+    init_scan_code(REDKEY_L_CTRL);
+    init_scan_code(REDKEY_A);
+    init_scan_code(REDKEY_S);
+    init_scan_code(REDKEY_D);
+    init_scan_code(REDKEY_F);
+    init_scan_code(REDKEY_G);
+    init_scan_code(REDKEY_H);
+    init_scan_code(REDKEY_J);
+    init_scan_code(REDKEY_K);
+    init_scan_code(REDKEY_L);
+    init_scan_code(REDKEY_SEMICOLON);
+    init_scan_code(REDKEY_QUOTE);
+    init_scan_code(REDKEY_BACK_QUOTE);
+    init_scan_code(REDKEY_L_SHIFT);
+    init_scan_code(REDKEY_BACK_SLASH);
+    init_scan_code(REDKEY_Z);
+    init_scan_code(REDKEY_X);
+    init_scan_code(REDKEY_C);
+    init_scan_code(REDKEY_V);
+    init_scan_code(REDKEY_B);
+    init_scan_code(REDKEY_N);
+    init_scan_code(REDKEY_M);
+    init_scan_code(REDKEY_COMMA);
+    init_scan_code(REDKEY_PERIOD);
+    init_scan_code(REDKEY_SLASH);
+    init_scan_code(REDKEY_R_SHIFT);
+    init_scan_code(REDKEY_PAD_MULTIPLY);
+    init_scan_code(REDKEY_L_ALT);
+    init_scan_code(REDKEY_SPACE);
+    init_scan_code(REDKEY_CAPS_LOCK);
+    init_scan_code(REDKEY_F1);
+    init_scan_code(REDKEY_F2);
+    init_scan_code(REDKEY_F3);
+    init_scan_code(REDKEY_F4);
+    init_scan_code(REDKEY_F5);
+    init_scan_code(REDKEY_F6);
+    init_scan_code(REDKEY_F7);
+    init_scan_code(REDKEY_F8);
+    init_scan_code(REDKEY_F9);
+    init_scan_code(REDKEY_F10);
+    init_scan_code(REDKEY_NUM_LOCK);
+    init_scan_code(REDKEY_SCROLL_LOCK);
+    init_scan_code(REDKEY_PAD_7);
+    init_scan_code(REDKEY_PAD_8);
+    init_scan_code(REDKEY_PAD_9);
+    init_scan_code(REDKEY_PAD_MINUS);
+    init_scan_code(REDKEY_PAD_4);
+    init_scan_code(REDKEY_PAD_5);
+    init_scan_code(REDKEY_PAD_6);
+    init_scan_code(REDKEY_PAD_PLUS);
+    init_scan_code(REDKEY_PAD_1);
+    init_scan_code(REDKEY_PAD_2);
+    init_scan_code(REDKEY_PAD_3);
+    init_scan_code(REDKEY_PAD_0);
+    init_scan_code(REDKEY_PAD_POINT);
+
+    init_scan_code(REDKEY_EUROPEAN);
+    init_scan_code(REDKEY_F11);
+    init_scan_code(REDKEY_F12);
+
+    init_scan_code(REDKEY_JAPANESE_HIRAGANA_KATAKANA);
+    init_scan_code(REDKEY_JAPANESE_BACKSLASH);
+    init_scan_code(REDKEY_JAPANESE_HENKAN);
+    init_scan_code(REDKEY_JAPANESE_MUHENKAN);
+    init_scan_code(REDKEY_JAPANESE_YEN);
+
+    init_korean_scan_code(REDKEY_KOREAN_HANGUL);
+    init_korean_scan_code(REDKEY_KOREAN_HANGUL_HANJA);
+
+    init_escape_scan_code(REDKEY_ESCAPE_BASE);
+    init_escape_scan_code(REDKEY_PAD_ENTER);
+    init_escape_scan_code(REDKEY_R_CTRL);
+    init_escape_scan_code(REDKEY_FAKE_L_SHIFT);
+    init_escape_scan_code(REDKEY_PAD_DIVIDE);
+    init_escape_scan_code(REDKEY_FAKE_R_SHIFT);
+    init_escape_scan_code(REDKEY_CTRL_PRINT_SCREEN);
+    init_escape_scan_code(REDKEY_R_ALT);
+    init_escape_scan_code(REDKEY_CTRL_BREAK);
+    init_escape_scan_code(REDKEY_HOME);
+    init_escape_scan_code(REDKEY_UP);
+    init_escape_scan_code(REDKEY_PAGEUP);
+    init_escape_scan_code(REDKEY_LEFT);
+    init_escape_scan_code(REDKEY_RIGHT);
+    init_escape_scan_code(REDKEY_END);
+    init_escape_scan_code(REDKEY_DOWN);
+    init_escape_scan_code(REDKEY_PAGEDOWN);
+    init_escape_scan_code(REDKEY_INSERT);
+    init_escape_scan_code(REDKEY_DELETE);
+    init_escape_scan_code(REDKEY_LEFT_CMD);
+    init_escape_scan_code(REDKEY_RIGHT_CMD);
+    init_escape_scan_code(REDKEY_MENU);
+
+    init_pause_scan_code();
+}
+
+inline uint32_t Application::get_make_scan_code(RedKey key)
+{
+    return _key_table[key]._make;
+}
+
+inline uint32_t Application::get_break_scan_code(RedKey key)
+{
+    return _key_table[key]._break;
+}
+
+void Application::unpress_all()
+{
+    for (int i = 0; i < REDKEY_NUM_KEYS; i++) {
+        if (_key_table[i].press) {
+            uint32_t scan_code = get_break_scan_code((RedKey)i);
+            ASSERT(scan_code);
+            _inputs_handler->on_key_up(scan_code);
+            _key_table[i].press = false;
+        }
+    }
+}
+
+void Application::on_connected()
+{
+}
+
+void Application::on_disconnecting()
+{
+    release_capture();
+}
+
+Menu* Application::get_app_menu()
+{
+    if (!*_app_menu) {
+        return NULL;
+    }
+    return (*_app_menu)->ref();
+}
+
+void Application::do_command(int command)
+{
+    switch (command) {
+    case APP_CMD_SEND_CTL_ALT_DEL:
+        send_alt_ctl_del();
+        break;
+    case APP_CMD_TOGGLE_FULL_SCREEN:
+        toggle_full_screen();
+        break;
+    case APP_CMD_SEND_TOGGLE_KEYS:
+        send_command_hotkey(APP_CMD_SEND_TOGGLE_KEYS);
+        break;
+    case APP_CMD_SEND_RELEASE_KEYS:
+        send_command_hotkey(APP_CMD_SEND_RELEASE_KEYS);
+        break;
+    case APP_CMD_SEND_CTL_ALT_END:
+        send_ctrl_alt_end();
+        break;
+    case APP_CMD_RELEASE_CAPTURE:
+        release_capture();
+        break;
+#ifdef RED_DEBUG
+    case APP_CMD_CONNECT:
+        do_connect();
+        break;
+    case APP_CMD_DISCONNECT:
+        do_disconnect();
+        break;
+#endif
+    }
+}
+
+#ifdef REDKEY_DEBUG
+
+static void show_red_key(RedKey key)
+{
+
+#define KEYCASE(red_key)    \
+    case red_key:           \
+        DBG(0, #red_key);   \
+        return;
+
+    switch (key) {
+        KEYCASE(REDKEY_INVALID);
+        KEYCASE(REDKEY_ESCAPE);
+        KEYCASE(REDKEY_1);
+        KEYCASE(REDKEY_2);
+        KEYCASE(REDKEY_3);
+        KEYCASE(REDKEY_4);
+        KEYCASE(REDKEY_5);
+        KEYCASE(REDKEY_6);
+        KEYCASE(REDKEY_7);
+        KEYCASE(REDKEY_8);
+        KEYCASE(REDKEY_9);
+        KEYCASE(REDKEY_0);
+        KEYCASE(REDKEY_MINUS);
+        KEYCASE(REDKEY_EQUALS);
+        KEYCASE(REDKEY_BACKSPACE);
+        KEYCASE(REDKEY_TAB);
+        KEYCASE(REDKEY_Q);
+        KEYCASE(REDKEY_W);
+        KEYCASE(REDKEY_E);
+        KEYCASE(REDKEY_R);
+        KEYCASE(REDKEY_T);
+        KEYCASE(REDKEY_Y);
+        KEYCASE(REDKEY_U);
+        KEYCASE(REDKEY_I);
+        KEYCASE(REDKEY_O);
+        KEYCASE(REDKEY_P);
+        KEYCASE(REDKEY_ENTER);
+        KEYCASE(REDKEY_L_BRACKET);
+        KEYCASE(REDKEY_R_BRACKET);
+        KEYCASE(REDKEY_L_CTRL);
+        KEYCASE(REDKEY_A);
+        KEYCASE(REDKEY_S);
+        KEYCASE(REDKEY_D);
+        KEYCASE(REDKEY_F);
+        KEYCASE(REDKEY_G);
+        KEYCASE(REDKEY_H);
+        KEYCASE(REDKEY_J);
+        KEYCASE(REDKEY_K);
+        KEYCASE(REDKEY_L);
+        KEYCASE(REDKEY_SEMICOLON);
+        KEYCASE(REDKEY_QUOTE);
+        KEYCASE(REDKEY_BACK_QUOTE);
+        KEYCASE(REDKEY_L_SHIFT);
+        KEYCASE(REDKEY_BACK_SLASH);
+        KEYCASE(REDKEY_Z);
+        KEYCASE(REDKEY_X);
+        KEYCASE(REDKEY_C);
+        KEYCASE(REDKEY_V);
+        KEYCASE(REDKEY_B);
+        KEYCASE(REDKEY_N);
+        KEYCASE(REDKEY_M);
+        KEYCASE(REDKEY_COMMA);
+        KEYCASE(REDKEY_PERIOD);
+        KEYCASE(REDKEY_SLASH);
+        KEYCASE(REDKEY_R_SHIFT);
+        KEYCASE(REDKEY_PAD_MULTIPLY);
+        KEYCASE(REDKEY_L_ALT);
+        KEYCASE(REDKEY_SPACE);
+        KEYCASE(REDKEY_CAPS_LOCK);
+        KEYCASE(REDKEY_F1);
+        KEYCASE(REDKEY_F2);
+        KEYCASE(REDKEY_F3);
+        KEYCASE(REDKEY_F4);
+        KEYCASE(REDKEY_F5);
+        KEYCASE(REDKEY_F6);
+        KEYCASE(REDKEY_F7);
+        KEYCASE(REDKEY_F8);
+        KEYCASE(REDKEY_F9);
+        KEYCASE(REDKEY_F10);
+        KEYCASE(REDKEY_NUM_LOCK);
+        KEYCASE(REDKEY_SCROLL_LOCK);
+        KEYCASE(REDKEY_PAD_7);
+        KEYCASE(REDKEY_PAD_8);
+        KEYCASE(REDKEY_PAD_9);
+        KEYCASE(REDKEY_PAD_MINUS);
+        KEYCASE(REDKEY_PAD_4);
+        KEYCASE(REDKEY_PAD_5);
+        KEYCASE(REDKEY_PAD_6);
+        KEYCASE(REDKEY_PAD_PLUS);
+        KEYCASE(REDKEY_PAD_1);
+        KEYCASE(REDKEY_PAD_2);
+        KEYCASE(REDKEY_PAD_3);
+        KEYCASE(REDKEY_PAD_0);
+        KEYCASE(REDKEY_PAD_POINT);
+        KEYCASE(REDKEY_F11);
+        KEYCASE(REDKEY_F12);
+        KEYCASE(REDKEY_PAD_ENTER);
+        KEYCASE(REDKEY_R_CTRL);
+        KEYCASE(REDKEY_FAKE_L_SHIFT);
+        KEYCASE(REDKEY_PAD_DIVIDE);
+        KEYCASE(REDKEY_FAKE_R_SHIFT);
+        KEYCASE(REDKEY_CTRL_PRINT_SCREEN);
+        KEYCASE(REDKEY_R_ALT);
+        KEYCASE(REDKEY_CTRL_BREAK);
+        KEYCASE(REDKEY_HOME);
+        KEYCASE(REDKEY_UP);
+        KEYCASE(REDKEY_PAGEUP);
+        KEYCASE(REDKEY_LEFT);
+        KEYCASE(REDKEY_RIGHT);
+        KEYCASE(REDKEY_END);
+        KEYCASE(REDKEY_DOWN);
+        KEYCASE(REDKEY_PAGEDOWN);
+        KEYCASE(REDKEY_INSERT);
+        KEYCASE(REDKEY_DELETE);
+        KEYCASE(REDKEY_LEFT_CMD);
+        KEYCASE(REDKEY_RIGHT_CMD);
+        KEYCASE(REDKEY_MENU);
+    default:
+        DBG(0, "???");
+    }
+}
+
+#endif
+
+void Application::on_key_down(RedKey key)
+{
+    if (key <= 0 || key >= REDKEY_NUM_KEYS) {
+        return;
+    }
+
+    uint32_t scan_code = get_make_scan_code(key);
+    if (!scan_code) {
+        LOG_WARN("no make code for %d", key);
+        return;
+    }
+    _key_table[key].press = true;
+
+    int command = get_hotkeys_commnad();
+    if (command != APP_CMD_INVALID) {
+        do_command(command);
+        return;
+    }
+
+#ifdef WIN32
+    if (!_active_screen->intercepts_sys_key() &&
+                                           (key == REDKEY_LEFT_CMD || key == REDKEY_RIGHT_CMD ||
+                                            key == REDKEY_MENU || _key_table[REDKEY_L_ALT].press)) {
+        _key_table[key].press = false;
+        return;
+    }
+    if ((_key_table[REDKEY_L_CTRL].press || _key_table[REDKEY_R_CTRL].press) &&
+        (_key_table[REDKEY_L_ALT].press || _key_table[REDKEY_R_ALT].press)) {
+        if (key == REDKEY_END || key == REDKEY_PAD_1) {
+            _key_table[key].press = false;
+            _inputs_handler->on_key_down(get_make_scan_code(REDKEY_DELETE));
+            _inputs_handler->on_key_up(get_break_scan_code(REDKEY_DELETE));
+        } else if (key == REDKEY_DELETE || key == REDKEY_PAD_POINT) {
+            _key_table[key].press = false;
+            return;
+        }
+    }
+#endif
+
+    _inputs_handler->on_key_down(scan_code);
+}
+
+void Application::on_key_up(RedKey key)
+{
+    if (key < 0 || key >= REDKEY_NUM_KEYS || !_key_table[key].press) {
+        return;
+    }
+    _key_table[key].press = false;
+    uint32_t scan_code = get_break_scan_code(key);
+    if (!scan_code) {
+        LOG_WARN("no break code for %d", key);
+        return;
+    }
+    _inputs_handler->on_key_up(scan_code);
+}
+
+void Application::on_deactivate_screen(RedScreen* screen)
+{
+    if (_active_screen == screen) {
+        release_capture();
+        _active_screen = NULL;
+    }
+}
+
+void Application::on_activate_screen(RedScreen* screen)
+{
+    _active_screen = screen;
+}
+
+void Application::on_app_activated()
+{
+    _active = true;
+    _inputs_handler->on_focus_in();
+}
+
+void Application::on_app_deactivated()
+{
+    _active = false;
+    _inputs_handler->on_focus_out();
+#ifdef WIN32
+    if (!_changing_screens) {
+        exit_full_screen();
+    }
+#endif
+}
+
+bool Application::rearrange_monitors(RedScreen& screen)
+{
+    if (!_full_screen) {
+        return false;
+    }
+    bool capture = release_capture();
+    prepare_monitors();
+    position_screens();
+    if (capture && _main_screen != &screen) {
+        capture = false;
+        _main_screen->activate();
+        _main_screen->capture_inputs();
+    }
+    return capture;
+}
+
+Monitor* Application::find_monitor(int id)
+{
+    ASSERT(_monitors);
+    std::list<Monitor*>::const_iterator iter = _monitors->begin();
+    for (; iter != _monitors->end(); iter++) {
+        Monitor *mon = *iter;
+        if (mon->get_id() == id) {
+            return mon;
+        }
+    }
+    return NULL;
+}
+
+Monitor* Application::get_monitor(int id)
+{
+    Monitor *mon = find_monitor(id);
+    if ((mon = find_monitor(id))) {
+        mon->set_used();
+    }
+    return mon;
+}
+
+void Application::assign_monitors()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            ASSERT(!_screens[i]->has_monitor());
+            _screens[i]->set_monitor(get_monitor(i));
+        }
+    }
+}
+
+void Application::prepare_monitors()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        Monitor* mon;
+        if (_screens[i] && (mon = _screens[i]->get_monitor())) {
+            Point size = _screens[i]->get_size();
+            mon->set_mode(size.x, size.y);
+        }
+    }
+    //todo: test match of monitors size/position against real world size/position
+}
+
+void Application::restore_monitors()
+{
+    //todo: renew monitors (destroy + init)
+    std::list<Monitor*>::const_iterator iter = _monitors->begin();
+    for (; iter != _monitors->end(); iter++) {
+        (*iter)->restore();
+    }
+}
+
+void Application::position_screens()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        Monitor* mon;
+        if (_screens[i] && (mon = _screens[i]->get_monitor())) {
+            _screens[i]->position_full_screen(mon->get_position());
+        }
+    }
+}
+
+void Application::hide()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            _screens[i]->hide();
+        }
+    }
+}
+
+void Application::show()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            _screens[i]->show();
+        }
+    }
+}
+
+void Application::external_show()
+{
+    DBG(0, "Entry, _screens.size()=%lu", _screens.size());
+    for (size_t i = 0; i < _screens.size(); ++i) {
+        DBG(0, "%lu", i);
+        if (_screens[i]) {
+            _screens[i]->external_show();
+        }
+    }
+}
+
+void Application::show_full_screen()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            _screens[i]->show_full_screen();
+        }
+    }
+}
+
+void Application::enter_full_screen()
+{
+    _changing_screens = true;
+    release_capture();
+    assign_monitors();
+    hide();
+    prepare_monitors();
+    position_screens();
+    show_full_screen();
+    _main_screen->activate();
+    _main_screen->capture_inputs();
+    _changing_screens = false;
+    _full_screen = true;
+}
+
+void Application::exit_full_screen()
+{
+    if (!_full_screen) {
+        return;
+    }
+    release_capture();
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            Monitor* mon;
+            _screens[i]->exit_full_screen();
+            if ((mon = _screens[i]->get_monitor())) {
+                _screens[i]->set_monitor(NULL);
+                mon->set_free();
+            }
+        }
+    }
+    restore_monitors();
+    _full_screen = false;
+    show();
+    _main_screen->activate();
+}
+
+bool Application::toggle_full_screen()
+{
+    if (_full_screen) {
+        exit_full_screen();
+    } else {
+        enter_full_screen();
+    }
+    return _full_screen;
+}
+
+void Application::minimize()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            _screens[i]->minimize();
+        }
+    }
+}
+
+void Application::destroy_monitors()
+{
+    for (int i = 0; i < (int)_screens.size(); i++) {
+        if (_screens[i]) {
+            _screens[i]->set_monitor(NULL);
+        }
+    }
+    Platform::destroy_monitors();
+    _monitors = NULL;
+}
+
+void Application::init_monitors()
+{
+    exit_full_screen();
+    destroy_monitors();
+    _monitors = &Platform::init_monitors();
+}
+
+void Application::on_monitors_change()
+{
+    if (Monitor::is_self_change()) {
+        return;
+    }
+    exit_full_screen();
+    init_monitors();
+}
+
+void Application::on_display_mode_change()
+{
+    _client.on_display_mode_change();
+}
+
+void Application::show_splash(int screen_id)
+{
+    if (screen_id != 0) {
+        return;
+    }
+    release_capture();
+    (*_gui_layer).set_splash_mode();
+}
+
+void Application::hide_splash(int screen_id)
+{
+    if (screen_id != 0) {
+        return;
+    }
+    (*_gui_layer).set_info_mode();
+}
+
+uint32_t Application::get_mouse_mode()
+{
+    return _client.get_mouse_mode();
+}
+
+void Application::set_title(std::wstring& title)
+{
+    _title = title;
+
+    for (size_t i = 0; i < _screens.size(); ++i) {
+        if (_screens[i]) {
+            _screens[i]->set_name(_title);
+        }
+    }
+}
+
+bool Application::is_key_set_pressed(const HotkeySet& key_set)
+{
+    HotkeySet::const_iterator iter = key_set.begin();
+
+    while (iter != key_set.end()) {
+        if (!(_key_table[iter->main].press || _key_table[iter->alter].press)) {
+            break;
+        }
+        ++iter;
+    }
+
+    return iter == key_set.end();
+}
+
+int Application::get_hotkeys_commnad()
+{
+    HotKeys::const_iterator iter = _hot_keys.begin();
+
+    while (iter != _hot_keys.end()) {
+        if (is_key_set_pressed(iter->second)) {
+            break;
+        }
+        ++iter;
+    }
+
+    return (iter != _hot_keys.end()) ? iter->first : APP_CMD_INVALID;
+}
+
+bool Application::is_cad_pressed()
+{
+    return ((_key_table[REDKEY_L_CTRL].press || _key_table[REDKEY_R_CTRL].press) &&
+            (_key_table[REDKEY_L_ALT].press || _key_table[REDKEY_R_ALT].press) &&
+            (_key_table[REDKEY_DELETE].press || _key_table[REDKEY_PAD_POINT].press));
+}
+
+void Application::send_key_down(RedKey key)
+{
+    _inputs_handler->on_key_down(get_make_scan_code(key));
+}
+
+void Application::send_key_up(RedKey key)
+{
+    _inputs_handler->on_key_up(get_break_scan_code(key));
+}
+
+void Application::send_alt_ctl_del()
+{
+    send_key_down(REDKEY_L_CTRL);
+    send_key_down(REDKEY_L_ALT);
+    send_key_down(REDKEY_DELETE);
+
+    send_key_up(REDKEY_DELETE);
+    send_key_up(REDKEY_L_ALT);
+    send_key_up(REDKEY_L_CTRL);
+}
+
+void Application::send_ctrl_alt_end()
+{
+    send_key_down(REDKEY_L_CTRL);
+    send_key_down(REDKEY_L_ALT);
+    send_key_down(REDKEY_END);
+
+    send_key_up(REDKEY_L_CTRL);
+    send_key_up(REDKEY_L_ALT);
+    send_key_up(REDKEY_END);
+}
+
+void Application::send_command_hotkey(int action)
+{
+    HotKeys::const_iterator iter = _hot_keys.find(action);
+    if (iter != _hot_keys.end()) {
+        send_hotkey_key_set(iter->second);
+    }
+}
+
+void Application::send_hotkey_key_set(const HotkeySet& key_set)
+{
+    HotkeySet::const_iterator iter;
+
+    for (iter = key_set.begin(); iter != key_set.end(); ++iter) {
+        send_key_down(iter->main);
+    }
+
+    for (iter = key_set.begin(); iter != key_set.end(); ++iter) {
+        send_key_up(iter->main);
+    }
+}
+
+static inline int str_to_port(const char *str)
+{
+    long port;
+    char *endptr;
+    port = strtol(str, &endptr, 0);
+    if (endptr != str + strlen(str) || port < 0 || port > 0xffff) {
+        return -1;
+    }
+    return port;
+}
+
+bool Application::set_channels_security(CmdLineParser& parser, bool on, char *val)
+{
+    RedPeer::ConnectionOptions::Type option;
+    option = (on) ? RedPeer::ConnectionOptions::CON_OP_SECURE :
+                    RedPeer::ConnectionOptions::CON_OP_UNSECURE;
+
+    typedef std::map< std::string, int> ChannelsNamesMap;
+    ChannelsNamesMap channels_names;
+    channels_names["main"] = RED_CHANNEL_MAIN;
+    channels_names["display"] = RED_CHANNEL_DISPLAY;
+    channels_names["inputs"] = RED_CHANNEL_INPUTS;
+    channels_names["cursor"] = RED_CHANNEL_CURSOR;
+    channels_names["playback"] = RED_CHANNEL_PLAYBACK;
+    channels_names["record"] = RED_CHANNEL_RECORD;
+
+    if (!strcmp(val, "all")) {
+        if ((val = parser.next_argument())) {
+            std::cout << "\"all\" is exclusive in secure-channels\n";
+            return false;
+        }
+        PeerConnectionOptMap::iterator iter = _peer_con_opt.begin();
+        for (; iter != _peer_con_opt.end(); iter++) {
+            (*iter).second = option;
+        }
+        return true;
+    }
+
+    do {
+        ChannelsNamesMap::iterator iter = channels_names.find(val);
+        if (iter == channels_names.end()) {
+            std::cout << "bad channel name \"" << val << "\" in secure-channels\n";
+            return false;
+        }
+        _peer_con_opt[(*iter).second] = option;
+    } while ((val = parser.next_argument()));
+    return true;
+}
+
+bool Application::set_canvas_option(CmdLineParser& parser, char *val)
+{
+    typedef std::map< std::string, CanvasOption> CanvasNamesMap;
+    CanvasNamesMap canvas_types;
+
+    canvas_types["cairo"] = CANVAS_OPTION_CAIRO;
+#ifdef WIN32
+    canvas_types["gdi"] = CANVAS_OPTION_GDI;
+#endif
+#ifdef USE_OGL
+    canvas_types["gl_fbo"] = CANVAS_OPTION_OGL_FBO;
+    canvas_types["gl_pbuff"] = CANVAS_OPTION_OGL_PBUFF;
+#endif
+    _canvas_types.clear();
+    do {
+        CanvasNamesMap::iterator iter = canvas_types.find(val);
+        if (iter == canvas_types.end()) {
+            std::cout << "bad canvas type \"" << val << "\"\n";
+            return false;
+        }
+        _canvas_types.resize(_canvas_types.size() + 1);
+        _canvas_types[_canvas_types.size() - 1] = (*iter).second;
+    } while ((val = parser.next_argument()));
+    return true;
+}
+
+bool Application::set_enable_channels(CmdLineParser& parser, bool enable, char *val)
+{
+    typedef std::map< std::string, int> ChannelsNamesMap;
+    ChannelsNamesMap channels_names;
+    channels_names["display"] = RED_CHANNEL_DISPLAY;
+    channels_names["inputs"] = RED_CHANNEL_INPUTS;
+    channels_names["cursor"] = RED_CHANNEL_CURSOR;
+    channels_names["playback"] = RED_CHANNEL_PLAYBACK;
+    channels_names["record"] = RED_CHANNEL_RECORD;
+
+    if (!strcmp(val, "all")) {
+        if ((val = parser.next_argument())) {
+            std::cout << "\"all\" is exclusive\n";
+            return false;
+        }
+        for (unsigned int i = 0; i < _enabled_channels.size(); i++) {
+            _enabled_channels[i] = enable;
+        }
+        return true;
+    }
+
+    do {
+        ChannelsNamesMap::iterator iter = channels_names.find(val);
+        if (iter == channels_names.end()) {
+            std::cout << "bad channel name \"" << val << "\"\n";
+            return false;
+        }
+        _enabled_channels[(*iter).second] = enable;
+    } while ((val = parser.next_argument()));
+    return true;
+}
+
+bool Application::process_cmd_line(int argc, char** argv)
+{
+    std::string host;
+    int sport = -1;
+    int port = -1;
+    bool auto_display_res = false;
+    bool full_screen = false;
+    std::string password;
+
+    enum {
+        SPICE_OPT_HOST = CmdLineParser::OPTION_FIRST_AVILABLE,
+        SPICE_OPT_PORT,
+        SPICE_OPT_SPORT,
+        SPICE_OPT_PASSWORD,
+        SPICE_OPT_FULL_SCREEN,
+        SPICE_OPT_SECURE_CHANNELS,
+        SPICE_OPT_UNSECURE_CHANNELS,
+        SPICE_OPT_ENABLE_CHANNELS,
+        SPICE_OPT_DISABLE_CHANNELS,
+        SPICE_OPT_CANVAS_TYPE,
+    };
+
+    CmdLineParser parser("Spice client", false);
+
+    parser.add(SPICE_OPT_HOST, "host", "spice server address", "host", true, 'h');
+    parser.set_reqired(SPICE_OPT_HOST);
+    parser.add(SPICE_OPT_PORT, "port", "spice server port", "port", true, 'p');
+    parser.add(SPICE_OPT_SPORT, "secure-port", "spice server secure port", "port", true, 's');
+    parser.add(SPICE_OPT_SECURE_CHANNELS, "secure-channels",
+               "force secure connection on the specified channels", "channel",
+               true);
+    parser.set_multi(SPICE_OPT_SECURE_CHANNELS, ',');
+    parser.add(SPICE_OPT_UNSECURE_CHANNELS, "unsecure-channels",
+               "force unsecure connection on the specified channels", "channel",
+               true);
+    parser.set_multi(SPICE_OPT_UNSECURE_CHANNELS, ',');
+    parser.add(SPICE_OPT_PASSWORD, "password", "server password", "password", true, 'w');
+    parser.add(SPICE_OPT_FULL_SCREEN, "full-screen", "open in full screen mode", "auto-conf",
+               false, 'f');
+
+    parser.add(SPICE_OPT_ENABLE_CHANNELS, "enable-channels", "enable channels", "channel", true);
+    parser.set_multi(SPICE_OPT_ENABLE_CHANNELS, ',');
+
+    parser.add(SPICE_OPT_DISABLE_CHANNELS, "disable-channels", "disable channels", "channel", true);
+    parser.set_multi(SPICE_OPT_DISABLE_CHANNELS, ',');
+
+    parser.add(SPICE_OPT_CANVAS_TYPE, "canvas-type", "set rendering canvas", "canvas_type", true);
+    parser.set_multi(SPICE_OPT_CANVAS_TYPE, ',');
+
+    _peer_con_opt[RED_CHANNEL_MAIN] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+    _peer_con_opt[RED_CHANNEL_DISPLAY] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+    _peer_con_opt[RED_CHANNEL_INPUTS] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+    _peer_con_opt[RED_CHANNEL_CURSOR] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+    _peer_con_opt[RED_CHANNEL_PLAYBACK] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+    _peer_con_opt[RED_CHANNEL_RECORD] = RedPeer::ConnectionOptions::CON_OP_INVALID;
+
+    parser.begin(argc, argv);
+
+    char* val;
+    int op;
+    while ((op = parser.get_option(&val)) != CmdLineParser::OPTION_DONE) {
+        switch (op) {
+        case SPICE_OPT_HOST:
+            host = val;
+            break;
+        case SPICE_OPT_PORT: {
+            if ((port = str_to_port(val)) == -1) {
+                std::cout << "invalid port " << val << "\n";
+                _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                return false;
+            }
+            break;
+        }
+        case SPICE_OPT_SPORT: {
+            if ((port = str_to_port(val)) == -1) {
+                std::cout << "invalid secure port " << val << "\n";
+                _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                return false;
+            }
+            sport = port;
+            break;
+        }
+        case SPICE_OPT_FULL_SCREEN:
+            if (val) {
+                if (strcmp(val, "auto-conf")) {
+                    std::cout << "invalid full screen mode " << val << "\n";
+                    _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                    return false;
+                }
+                auto_display_res = true;
+            }
+            full_screen = true;
+            break;
+        case SPICE_OPT_PASSWORD:
+            password = val;
+            break;
+        case SPICE_OPT_SECURE_CHANNELS:
+            if (!set_channels_security(parser, true, val)) {
+                return false;
+            }
+            break;
+        case SPICE_OPT_UNSECURE_CHANNELS:
+            if (!set_channels_security(parser, false, val)) {
+                return false;
+            }
+            break;
+        case SPICE_OPT_ENABLE_CHANNELS:
+            if (!set_enable_channels(parser, true, val)) {
+                std::cout << "invalid channels " << val << "\n";
+                _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                return false;
+            }
+            break;
+        case SPICE_OPT_DISABLE_CHANNELS:
+            if (!set_enable_channels(parser, false, val)) {
+                std::cout << "invalid channels " << val << "\n";
+                _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                return false;
+            }
+            break;
+        case SPICE_OPT_CANVAS_TYPE:
+            if (!set_canvas_option(parser, val)) {
+                std::cout << "invalid canvas option " << val << "\n";
+                _exit_code = SPICEC_ERROR_CODE_INVALID_ARG;
+                return false;
+            }
+            break;
+        case CmdLineParser::OPTION_HELP:
+            parser.show_help();
+            return false;
+        case CmdLineParser::OPTION_ERROR:
+            return false;
+        default:
+            throw Exception("cmd line error");
+        }
+    }
+
+    if (parser.is_set(SPICE_OPT_SECURE_CHANNELS) && !parser.is_set(SPICE_OPT_SPORT)) {
+        std::cout << "missing --secure-port\n";
+        return false;
+    }
+
+    PeerConnectionOptMap::iterator iter = _peer_con_opt.begin();
+    for (; iter != _peer_con_opt.end(); iter++) {
+        if ((*iter).second == RedPeer::ConnectionOptions::CON_OP_SECURE) {
+            continue;
+        }
+
+        if ((*iter).second == RedPeer::ConnectionOptions::CON_OP_UNSECURE) {
+            continue;
+        }
+
+        if (parser.is_set(SPICE_OPT_PORT) && parser.is_set(SPICE_OPT_SPORT)) {
+            (*iter).second = RedPeer::ConnectionOptions::CON_OP_BOTH;
+            continue;
+        }
+
+        if (parser.is_set(SPICE_OPT_PORT)) {
+            (*iter).second = RedPeer::ConnectionOptions::CON_OP_UNSECURE;
+            continue;
+        }
+
+        if (parser.is_set(SPICE_OPT_SPORT)) {
+            (*iter).second = RedPeer::ConnectionOptions::CON_OP_SECURE;
+            continue;
+        }
+        std::cout << "missing --port or --sport\n";
+        return false;
+    }
+
+    if (_enabled_channels[RED_CHANNEL_DISPLAY]) {
+        _client.register_channel_factory(DisplayChannel::Factory());
+    }
+
+    if (_enabled_channels[RED_CHANNEL_CURSOR]) {
+        _client.register_channel_factory(CursorChannel::Factory());
+    }
+
+    if (_enabled_channels[RED_CHANNEL_INPUTS]) {
+        _client.register_channel_factory(InputsChannel::Factory());
+    }
+
+    if (_enabled_channels[RED_CHANNEL_PLAYBACK]) {
+        _client.register_channel_factory(PlaybackChannel::Factory());
+    }
+
+    if (_enabled_channels[RED_CHANNEL_RECORD]) {
+        _client.register_channel_factory(RecordChannel::Factory());
+    }
+
+    _client.init(host.c_str(), port, sport, password.c_str(), auto_display_res);
+    if (auto_display_res) {
+        Monitor* mon = find_monitor(0);
+        ASSERT(mon);
+        Point size = mon->get_size();
+        _main_screen->set_mode(size.x, size.y, 32);
+    }
+
+    if (full_screen) {
+        enter_full_screen();
+    } else {
+        _main_screen->show(true, NULL);
+    }
+    return true;
+}
+
+void Application::init_logger()
+{
+    std::string temp_dir_name;
+    Platform::get_temp_dir(temp_dir_name);
+    std::string log_file_name = temp_dir_name + "spicec.log";
+
+    int fd = ::open(log_file_name.c_str(), O_CREAT | O_APPEND | O_WRONLY, 0644);
+    if (fd == -1) {
+        log4cpp::BasicConfigurator::configure();
+        return;
+    }
+    log4cpp::Category& root = log4cpp::Category::getRoot();
+#ifdef RED_DEBUG
+    root.setPriority(log4cpp::Priority::DEBUG);
+    root.removeAllAppenders();
+    ::close(fd);
+    root.addAppender(new log4cpp::RollingFileAppender("_", log_file_name));
+#else
+    root.setPriority(log4cpp::Priority::INFO);
+    root.removeAllAppenders();
+    root.addAppender(new log4cpp::FileAppender("_", fd));
+#endif
+}
+
+void Application::init_globals()
+{
+    init_logger();
+    srand((unsigned)time(NULL));
+
+    SSL_library_init();
+    SSL_load_error_strings();
+
+    cairo_canvas_init();
+#ifdef USE_OGL
+    gl_canvas_init();
+#endif
+    quic_init();
+#ifdef WIN32
+    gdi_canvas_init();
+#endif
+
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+    MUTEX_INIT(cairo_surface_user_data_mutex);
+#endif
+
+    Platform::init();
+    RedWindow::init();
+}
+
+int Application::main(int argc, char** argv, const char* version_str)
+{
+    init_globals();
+    LOG_INFO("starting %s", version_str);
+    std::auto_ptr<Application> app(new Application());
+    AutoAbort auto_abort(*app.get());
+    if (!app->process_cmd_line(argc, argv)) {
+        return app->_exit_code;
+    }
+    return app->run();
+}
+
diff --git a/client/application.h b/client/application.h
new file mode 100644
index 00000000..1a14c5ed
--- /dev/null
+++ b/client/application.h
@@ -0,0 +1,267 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_APPLICATION
+#define _H_APPLICATION
+
+#include "common.h"
+#include "threads.h"
+#include "red_client.h"
+#include "red_key.h"
+#include "platform.h"
+#include "menu.h"
+#include "hot_keys.h"
+
+class RedScreen;
+class Application;
+class ScreenLayer;
+class GUILayer;
+class InputsHandler;
+class Monitor;
+class CmdLineParser;
+class Menu;
+
+class Event {
+public:
+    Event() : _refs (1) {}
+
+    virtual void responce(Application& application) = 0;
+
+    Event* ref() { ++_refs; return this;}
+    void unref() {if (--_refs == 0) delete this;}
+
+protected:
+    virtual ~Event() {}
+
+    AtomicCount _refs;
+    friend class Application;
+    uint32_t _generation;
+};
+
+class SyncEvent: public Event {
+public:
+    SyncEvent();
+
+    void wait();
+    bool success() { return !_err;}
+
+    virtual void do_responce(Application& application) {}
+
+protected:
+    virtual ~SyncEvent();
+
+private:
+    virtual void responce(Application& application);
+
+private:
+    Mutex _mutex;
+    Condition _condition;
+    bool _err;
+    bool _ready;
+};
+
+class ConnectedEvent: public Event {
+public:
+    ConnectedEvent() : Event() {}
+    virtual void responce(Application& application);
+};
+
+class DisconnectedEvent: public Event {
+public:
+    DisconnectedEvent() : Event() {}
+    virtual void responce(Application& application);
+};
+
+class CoonnectionError: public Event {
+public:
+    CoonnectionError(int error_code) : Event(), _error_code (error_code) {}
+
+    virtual void responce(Application& application);
+
+private:
+    int _error_code;
+};
+
+class ErrorEvent: public Event {
+public:
+    ErrorEvent() : Event() {}
+    virtual void responce(Application& application);
+};
+
+struct MonitorInfo {
+    int depth;
+    Point size;
+    Point position;
+};
+
+class MonitorsQuery: public SyncEvent {
+public:
+    MonitorsQuery() {}
+
+    virtual void do_responce(Application& application);
+
+    std::vector<MonitorInfo>& get_monitors() {return _monitors;}
+
+private:
+    std::vector<MonitorInfo> _monitors;
+};
+
+struct KeyInfo {
+    uint32_t _make;
+    uint32_t _break;
+    bool press;
+};
+
+enum CanvasOption {
+    CANVAS_OPTION_INVALID,
+    CANVAS_OPTION_CAIRO,
+#ifdef WIN32
+    CANVAS_OPTION_GDI,
+#endif
+#ifdef USE_OGL
+    CANVAS_OPTION_OGL_FBO,
+    CANVAS_OPTION_OGL_PBUFF,
+#endif
+};
+
+class Application : public Platform::EventListener,
+                    public Platform::DisplayModeListner,
+                    public CommandTarget {
+public:
+    Application();
+    virtual ~Application();
+
+    int run();
+    void quit(int exit_code);
+    void push_event(Event* event);
+    void set_inputs_handler(InputsHandler& handler);
+    void remove_inputs_handler(InputsHandler& handler);
+    RedScreen* find_screen(int id);
+    RedScreen* get_screen(int id);
+
+    void on_screen_destroyed(int id, bool was_captured);
+    void on_mouse_motion(int dx, int dy, int buttons_state);
+    void on_mouse_position(int x, int y, int buttons_state, int display_id);
+    void on_mouse_down(int button, int buttons_state);
+    void on_mouse_up(int button, int buttons_state);
+    void on_key_down(RedKey key);
+    void on_key_up(RedKey key);
+    void on_deactivate_screen(RedScreen* screen);
+    void on_activate_screen(RedScreen* screen);
+    virtual void on_app_activated();
+    virtual void on_app_deactivated();
+    virtual void on_monitors_change();
+    virtual void on_display_mode_change();
+    void on_connected();
+    void on_disconnecting();
+
+    bool rearrange_monitors(RedScreen& screen);
+    void enter_full_screen();
+    void exit_full_screen();
+    bool toggle_full_screen();
+    void minimize();
+    void show_splash(int screen_id);
+    void hide_splash(int screen_id);
+    void set_title(std::wstring& title);
+    void hide();
+    void show();
+    void external_show();
+    void connect();
+    const PeerConnectionOptMap& get_con_opt_map() {return _peer_con_opt;}
+    uint32_t get_mouse_mode();
+    const std::vector<int>& get_canvas_types() { return _canvas_types;}
+
+    Menu* get_app_menu();
+    virtual void do_command(int command);
+
+    static int main(int argc, char** argv, const char* version_str);
+
+private:
+    bool set_channels_security(CmdLineParser& parser, bool on, char *val);
+    bool set_enable_channels(CmdLineParser& parser, bool enable, char *val);
+    bool set_canvas_option(CmdLineParser& parser, char *val);
+    bool process_cmd_line(int argc, char** argv);
+    void process_events();
+    int message_loop();
+    void abort();
+    void init_scan_code(int index);
+    void init_korean_scan_code(int index);
+    void init_escape_scan_code(int index);
+    void init_pause_scan_code();
+    void init_key_table();
+    void init_menu();
+    uint32_t get_make_scan_code(RedKey key);
+    uint32_t get_break_scan_code(RedKey key);
+    void unpress_all();
+    bool release_capture();
+    bool do_connect();
+    bool do_disconnect();
+
+    Monitor* find_monitor(int id);
+    Monitor* get_monitor(int id);
+    void init_monitors();
+    void destroy_monitors();
+    void assign_monitors();
+    void restore_monitors();
+    void prepare_monitors();
+    void position_screens();
+    void show_full_screen();
+    void send_key_down(RedKey key);
+    void send_key_up(RedKey key);
+    void send_alt_ctl_del();
+    void send_ctrl_alt_end();
+    void send_command_hotkey(int command);
+    void send_hotkey_key_set(const HotkeySet& key_set);
+    void menu_item_callback(unsigned int item_id);
+    int get_hotkeys_commnad();
+    bool is_key_set_pressed(const HotkeySet& key_set);
+    bool is_cad_pressed();
+
+    static void init_logger();
+    static void init_globals();
+
+    friend class MonitorsQuery;
+    friend class AutoAbort;
+
+private:
+    RedClient _client;
+    PeerConnectionOptMap _peer_con_opt;
+    std::vector<bool> _enabled_channels;
+    std::vector<RedScreen*> _screens;
+    std::list<Event*> _events;
+    RedScreen* _main_screen;
+    Mutex _events_lock;
+    bool _quitting;
+    bool _active;
+    bool _full_screen;
+    bool _changing_screens;
+    int _exit_code;
+    uint32_t _events_gen;
+    RedScreen* _active_screen;
+    KeyInfo _key_table[REDKEY_NUM_KEYS];
+    HotKeys _hot_keys;
+    CommandsMap _commands_map;
+    std::auto_ptr<GUILayer> _gui_layer;
+    InputsHandler* _inputs_handler;
+    const MonitorsList* _monitors;
+    std::wstring _title;
+    std::vector<int> _canvas_types;
+    AutoRef<Menu> _app_menu;
+};
+
+#endif
+
diff --git a/client/audio_channels.h b/client/audio_channels.h
new file mode 100644
index 00000000..76150782
--- /dev/null
+++ b/client/audio_channels.h
@@ -0,0 +1,101 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_AUDIO_CHANNELS
+#define _H_AUDIO_CHANNELS
+
+#include <celt051/celt.h>
+
+#include "red_channel.h"
+#include "debug.h"
+
+class ChannelFactory;
+
+class WavePlaybackAbstract;
+class WaveRecordAbstract;
+class RecordSamplesMessage;
+
+class PlaybackChannel: public RedChannel {
+public:
+    PlaybackChannel(RedClient& client, uint32_t id);
+    ~PlaybackChannel(void);
+    bool abort(void);
+
+    static ChannelFactory& Factory();
+
+private:
+    void handle_mode(RedPeer::InMessage* message);
+    void handle_start(RedPeer::InMessage* message);
+    void handle_stop(RedPeer::InMessage* message);
+    void handle_raw_data(RedPeer::InMessage* message);
+    void handle_celt_data(RedPeer::InMessage* message);
+    void null_handler(RedPeer::InMessage* message);
+    void disable();
+
+    void set_data_handler();
+
+private:
+    WavePlaybackAbstract* _wave_player;
+    uint32_t _mode;
+    uint32_t _frame_bytes;
+    CELTMode *_celt_mode;
+    CELTDecoder *_celt_decoder;
+    bool _playing;
+    uint32_t _frame_count;
+};
+
+class RecordChannel: public RedChannel, private Platform::RecordClinet {
+public:
+    RecordChannel(RedClient& client, uint32_t id);
+    ~RecordChannel(void);
+
+    bool abort(void);
+
+    static ChannelFactory& Factory();
+
+private:
+    void handle_start(RedPeer::InMessage* message);
+    void handle_stop(RedPeer::InMessage* message);
+
+    virtual void on_connect();
+
+    virtual void add_evnet_sorce(EventsLoop::File& evnet_sorce);
+    virtual void remove_evnet_sorce(EventsLoop::File& evnet_sorce);
+    virtual void add_evnet_sorce(EventsLoop::Trigger& evnet_sorce);
+    virtual void remove_evnet_sorce(EventsLoop::Trigger& evnet_sorce);
+    virtual void push_frame(uint8_t *frame);
+
+    void send_start_mark();
+    void release_message(RecordSamplesMessage *message);
+    RecordSamplesMessage * get_message();
+
+private:
+    WaveRecordAbstract* _wave_recorder;
+    Mutex _messages_lock;
+    std::list<RecordSamplesMessage *> _messages;
+    int _mode;
+    CELTMode *_celt_mode;
+    CELTEncoder *_celt_encoder;
+    uint32_t _frame_bytes;
+
+    static int data_mode;
+
+    friend class RecordSamplesMessage;
+};
+
+#endif
+
diff --git a/client/audio_devices.h b/client/audio_devices.h
new file mode 100644
index 00000000..56bc6c9e
--- /dev/null
+++ b/client/audio_devices.h
@@ -0,0 +1,52 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_AUDIO_DEVICES
+#define _H_AUDIO_DEVICES
+
+class WavePlaybackAbstract {
+public:
+    WavePlaybackAbstract() {}
+    virtual ~WavePlaybackAbstract() {}
+
+    virtual bool write(uint8_t* frame) = 0;
+    virtual bool abort() = 0;
+    virtual void stop() = 0;
+    virtual uint32_t get_delay_ms() = 0;
+
+    enum {
+        FRAME_SIZE = 256,
+    };
+};
+
+class WaveRecordAbstract {
+public:
+    WaveRecordAbstract() {}
+    virtual ~WaveRecordAbstract() {}
+
+
+    virtual void start() = 0;
+    virtual void stop() = 0;
+    virtual bool abort() = 0;
+
+    enum {
+        FRAME_SIZE = 256,
+    };
+};
+
+#endif
+
diff --git a/client/cache.hpp b/client/cache.hpp
new file mode 100644
index 00000000..72340e16
--- /dev/null
+++ b/client/cache.hpp
@@ -0,0 +1,121 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CACHE
+#define _H_CACHE
+
+#include "utils.h"
+
+/*class Cache::Treat {
+    T* get(T*);
+    void release(T*);
+    const char* name();
+};*/
+
+template <class T, class Treat, int HASH_SIZE>
+class Cache {
+public:
+    Cache()
+    {
+        memset(_hash, 0, sizeof(_hash));
+    }
+
+    ~Cache()
+    {
+        clear();
+    }
+
+    void add(uint64_t id, T* data)
+    {
+        Item** item = &_hash[key(id)];
+
+        while (*item) {
+            if ((*item)->id == id) {
+                THROW("%s id %lu, double insert", Treat::name(), id);
+            }
+            item = &(*item)->next;
+        }
+        *item = new Item(id, data);
+    }
+
+    T* get(uint64_t id)
+    {
+        Item* item = _hash[key(id)];
+
+        while (item && item->id != id) {
+            item = item->next;
+        }
+
+        if (!item) {
+            THROW("%s id %lu, not found", Treat::name(), id);
+        }
+        return Treat::get(item->data);
+    }
+
+    void remove(uint64_t id)
+    {
+        Item** item = &_hash[key(id)];
+
+        while (*item) {
+            if ((*item)->id == id) {
+                Item *rm_item = *item;
+                *item = rm_item->next;
+                delete rm_item;
+                return;
+            }
+            item = &(*item)->next;
+        }
+        THROW("%s id %lu, not found", Treat::name(), id);
+    }
+
+    void clear()
+    {
+        for (int i = 0; i < HASH_SIZE; i++) {
+            while (_hash[i]) {
+                Item *item = _hash[i];
+                _hash[i] = item->next;
+                delete item;
+            }
+        }
+    }
+
+private:
+    inline uint32_t key(uint64_t id) {return uint32_t(id) % HASH_SIZE;}
+
+private:
+    class Item {
+    public:
+        Item(uint64_t in_id, T* data)
+            : id (in_id)
+            , next (NULL)
+            , data (Treat::get(data)) {}
+
+        ~Item()
+        {
+            Treat::release(data);
+        }
+
+        uint64_t id;
+        Item* next;
+        T* data;
+    };
+
+    Item* _hash[HASH_SIZE];
+};
+
+#endif
+
diff --git a/client/cairo_canvas.cpp b/client/cairo_canvas.cpp
new file mode 100644
index 00000000..54211e4d
--- /dev/null
+++ b/client/cairo_canvas.cpp
@@ -0,0 +1,24 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "utils.h"
+
+#define CANVAS_ERROR(format, ...) THROW(format, ## __VA_ARGS__)
+
+#include "../common/cairo_canvas.c"
+
diff --git a/client/canvas.cpp b/client/canvas.cpp
new file mode 100644
index 00000000..310cdec9
--- /dev/null
+++ b/client/canvas.cpp
@@ -0,0 +1,251 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "canvas.h"
+#include "utils.h"
+#include "debug.h"
+
+
+Canvas::Canvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+               GlzDecoderWindow &glz_decoder_window)
+    : _pixmap_cache (pixmap_cache)
+    , _palette_cache (palette_cache)
+    , _glz_decoder(glz_decoder_window, _glz_handler, _glz_debug)
+{
+}
+
+Canvas::~Canvas()
+{
+}
+
+inline void Canvas::access_test(void *ptr, size_t size)
+{
+    if ((unsigned long)ptr < _base || (unsigned long)ptr + size > _max) {
+        THROW("access violation %p %lu", ptr, size);
+    }
+}
+
+void Canvas::localalize_ptr(ADDRESS* data)
+{
+    if (*data) {
+        *data += _base;
+    }
+}
+
+void Canvas::localalize_image(ADDRESS* in_bitmap)
+{
+    ImageDescriptor* image;
+
+    ASSERT(*in_bitmap);
+    localalize_ptr(in_bitmap);
+    image = (ImageDescriptor*)GET_ADDRESS(*in_bitmap);
+    switch (image->type) {
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)image;
+        localalize_ptr(&bitmap->bitmap.data);
+        if (bitmap->bitmap.palette && !(bitmap->bitmap.flags & BITMAP_PAL_FROM_CACHE)) {
+            localalize_ptr(&bitmap->bitmap.palette);
+        }
+        break;
+    }
+    case IMAGE_TYPE_LZ_PLT: {
+        LZ_PLTImage *lzImage = (LZ_PLTImage *)image;
+        ASSERT(lzImage->lz_plt.palette);
+        if (!(lzImage->lz_plt.flags & BITMAP_PAL_FROM_CACHE)) {
+            localalize_ptr(&lzImage->lz_plt.palette);
+        }
+        break;
+    }
+    case IMAGE_TYPE_LZ_RGB:
+    case IMAGE_TYPE_GLZ_RGB:
+    case IMAGE_TYPE_QUIC:
+        break;
+    case IMAGE_TYPE_FROM_CACHE:
+        break;
+    default:
+        THROW("invalid image type %u", image->type);
+    }
+}
+
+void Canvas::localalize_brush(Brush& brush)
+{
+    if (brush.type == BRUSH_TYPE_PATTERN) {
+        localalize_image(&brush.u.pattern.pat);
+    }
+}
+
+void Canvas::localalize_attr(LineAttr& attr)
+{
+    if (attr.style_nseg) {
+        localalize_ptr(&attr.style);
+    }
+}
+
+void Canvas::localalize_mask(QMask& mask)
+{
+    if (mask.bitmap) {
+        localalize_image(&mask.bitmap);
+    }
+}
+
+void Canvas::begin_draw(RedDrawBase& base, int size, size_t min_size)
+{
+    _base = (unsigned long)&base;
+    _max = _base + size;
+    set_access_params(_base, _base, _max);
+    access_test(&base, min_size);
+    localalize_ptr(&base.clip.data);
+}
+
+void Canvas::draw_fill(RedFill& fill, int size)
+{
+    begin_draw(fill.base, size, sizeof(RedFill));
+    localalize_brush(fill.data.brush);
+    localalize_mask(fill.data.mask);
+    draw_fill(&fill.base.box, &fill.base.clip, &fill.data);
+}
+
+void Canvas::draw_text(RedText& text, int size)
+{
+    begin_draw(text.base, size, sizeof(RedText));
+    localalize_brush(text.data.fore_brush);
+    localalize_brush(text.data.back_brush);
+    localalize_ptr(&text.data.str);
+    draw_text(&text.base.box, &text.base.clip, &text.data);
+}
+
+void Canvas::draw_opaque(RedOpaque& opaque, int size)
+{
+    begin_draw(opaque.base, size, sizeof(RedOpaque));
+    localalize_brush(opaque.data.brush);
+    localalize_image(&opaque.data.src_bitmap);
+    localalize_mask(opaque.data.mask);
+    draw_opaque(&opaque.base.box, &opaque.base.clip, &opaque.data);
+}
+
+void Canvas::draw_copy(RedCopy& copy, int size)
+{
+    begin_draw(copy.base, size, sizeof(RedCopy));
+    localalize_image(&copy.data.src_bitmap);
+    localalize_mask(copy.data.mask);
+    draw_copy(&copy.base.box, &copy.base.clip, &copy.data);
+}
+
+void Canvas::draw_transparent(RedTransparent& transparent, int size)
+{
+    begin_draw(transparent.base, size, sizeof(RedTransparent));
+    localalize_image(&transparent.data.src_bitmap);
+    draw_transparent(&transparent.base.box, &transparent.base.clip, &transparent.data);
+}
+
+void Canvas::draw_alpha_blend(RedAlphaBlend& alpha_blend, int size)
+{
+    begin_draw(alpha_blend.base, size, sizeof(RedAlphaBlend));
+    localalize_image(&alpha_blend.data.src_bitmap);
+    draw_alpha_blend(&alpha_blend.base.box, &alpha_blend.base.clip, &alpha_blend.data);
+}
+
+void Canvas::copy_bits(RedCopyBits& copy, int size)
+{
+    begin_draw(copy.base, size, sizeof(RedCopyBits));
+    copy_bits(&copy.base.box, &copy.base.clip, &copy.src_pos);
+}
+
+void Canvas::draw_blend(RedBlend& blend, int size)
+{
+    begin_draw(blend.base, size, sizeof(RedBlend));
+    localalize_image(&blend.data.src_bitmap);
+    localalize_mask(blend.data.mask);
+    draw_blend(&blend.base.box, &blend.base.clip, &blend.data);
+}
+
+void Canvas::draw_blackness(RedBlackness& blackness, int size)
+{
+    begin_draw(blackness.base, size, sizeof(RedBlackness));
+    localalize_mask(blackness.data.mask);
+    draw_blackness(&blackness.base.box, &blackness.base.clip, &blackness.data);
+}
+
+void Canvas::draw_whiteness(RedWhiteness& whiteness, int size)
+{
+    begin_draw(whiteness.base, size, sizeof(RedWhiteness));
+    localalize_mask(whiteness.data.mask);
+    draw_whiteness(&whiteness.base.box, &whiteness.base.clip, &whiteness.data);
+}
+
+void Canvas::draw_invers(RedInvers& invers, int size)
+{
+    begin_draw(invers.base, size, sizeof(RedInvers));
+    localalize_mask(invers.data.mask);
+    draw_invers(&invers.base.box, &invers.base.clip, &invers.data);
+}
+
+void Canvas::draw_rop3(RedRop3& rop3, int size)
+{
+    begin_draw(rop3.base, size, sizeof(RedRop3));
+    localalize_brush(rop3.data.brush);
+    localalize_image(&rop3.data.src_bitmap);
+    localalize_mask(rop3.data.mask);
+    draw_rop3(&rop3.base.box, &rop3.base.clip, &rop3.data);
+}
+
+void Canvas::draw_stroke(RedStroke& stroke, int size)
+{
+    begin_draw(stroke.base, size, sizeof(RedStroke));
+    localalize_brush(stroke.data.brush);
+    localalize_ptr(&stroke.data.path);
+    localalize_attr(stroke.data.attr);
+    draw_stroke(&stroke.base.box, &stroke.base.clip, &stroke.data);
+}
+
+void Canvas::bits_cache_put(void *opaque, uint64_t id, cairo_surface_t *surface)
+{
+    PixmapCache* cache = static_cast<PixmapCache*>(opaque);
+    cache->add(id, surface);
+}
+
+cairo_surface_t* Canvas::bits_cache_get(void *opaque, uint64_t id)
+{
+    PixmapCache* cache = static_cast<PixmapCache*>(opaque);
+    return cache->get(id);
+}
+
+void Canvas::palette_cache_put(void *opaque, Palette *palette)
+{
+    PaletteCache* cache = static_cast<PaletteCache*>(opaque);
+    AutoRef<CachedPalette> cached_palette(new CachedPalette(palette));
+    cache->add(palette->unique, *cached_palette);
+}
+
+Palette* Canvas::palette_cache_get(void *opaque, uint64_t id)
+{
+    PaletteCache* cache = static_cast<PaletteCache*>(opaque);
+    return cache->get(id)->palette();
+}
+
+void Canvas::palette_cache_release(Palette* palette)
+{
+    CachedPalette::unref(palette);
+}
+
+void Canvas::glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data)
+{
+    GlzDecoder* decoder = static_cast<GlzDecoder*>(opaque);
+    decoder->decode(data, plt, usr_data);
+}
+
diff --git a/client/canvas.h b/client/canvas.h
new file mode 100644
index 00000000..55415e31
--- /dev/null
+++ b/client/canvas.h
@@ -0,0 +1,265 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CANVAS
+#define _H_CANVAS
+
+#include "common.h"
+#include "debug.h"
+#include "cairo.h"
+#include "red.h"
+#include "cache.hpp"
+#include "shared_cache.hpp"
+#include "canvas_utils.h"
+#include "glz_decoded_image.h"
+#include "glz_decoder.h"
+
+enum CanvasType {
+    CANVAS_TYPE_INVALID,
+    CANVAS_TYPE_CAIRO,
+    CANVAS_TYPE_GL,
+    CANVAS_TYPE_GDI,
+};
+
+struct QRegion;
+
+class PixmapCacheTreat {
+public:
+    static inline cairo_surface_t *get(cairo_surface_t *surf)
+    {
+        return cairo_surface_reference(surf);
+    }
+
+    static inline void release(cairo_surface_t *surf)
+    {
+        cairo_surface_destroy(surf);
+    }
+
+    static const char* name() { return "pixmap";}
+};
+
+typedef SharedCache<cairo_surface_t, PixmapCacheTreat, 1024> PixmapCache;
+
+class CachedPalette {
+public:
+    CachedPalette(Palette* palette)
+        : _refs(1)
+    {
+        int size = sizeof(Palette) + palette->num_ents * sizeof(uint32_t);
+        CachedPalette **ptr = (CachedPalette **)new uint8_t[size + sizeof(CachedPalette *)];
+        *ptr = this;
+        _palette = (Palette*)(ptr + 1);
+        memcpy(_palette, palette, size);
+    }
+
+    CachedPalette* ref()
+    {
+        _refs++;
+        return this;
+    }
+
+    void unref()
+    {
+        if (--_refs == 0) {
+            delete this;
+        }
+    }
+
+    static void unref(Palette *pal)
+    {
+        CachedPalette **ptr = (CachedPalette **)pal;
+        (*(ptr - 1))->unref();
+    }
+
+    Palette* palette() { return _palette;}
+
+private:
+    ~CachedPalette()
+    {
+        delete[] (uint8_t *)((CachedPalette **)_palette - 1);
+    }
+
+private:
+    int _refs;
+    Palette* _palette;
+};
+
+class PaletteCacheTreat {
+public:
+    static inline CachedPalette* get(CachedPalette* palette)
+    {
+        return palette->ref();
+    }
+
+    static inline void release(CachedPalette* palette)
+    {
+        palette->unref();
+    }
+
+    static const char* name() { return "palette";}
+};
+
+typedef Cache<CachedPalette, PaletteCacheTreat, 1024> PaletteCache;
+
+/* Lz decoder related classes */
+
+class GlzDecodedSurface: public GlzDecodedImage {
+public:
+    GlzDecodedSurface(uint64_t id, uint64_t win_head_id, uint8_t *data, int size,
+                      int bytes_per_pixel, cairo_surface_t *surface)
+        : GlzDecodedImage(id, win_head_id, data, size, bytes_per_pixel)
+        , _surface (surface)
+    {
+        cairo_surface_reference(_surface);
+    }
+
+    virtual ~GlzDecodedSurface()
+    {
+        cairo_surface_destroy(_surface);
+    }
+
+private:
+    cairo_surface_t *_surface;
+};
+
+class GlzDecodeSurfaceHandler: public GlzDecodeHandler {
+public:
+    virtual GlzDecodedImage *alloc_image(void *opaque_usr_info, uint64_t image_id,
+                                         uint64_t image_win_head_id, LzImageType type,
+                                         int width, int height, int gross_pixels,
+                                         int n_bytes_per_pixel, bool top_down)
+    {
+        cairo_surface_t *surface = alloc_lz_image_surface((LzDecodeUsrData *)opaque_usr_info,
+                                                          type, width, height, gross_pixels,
+                                                          top_down);
+        uint8_t *data = cairo_image_surface_get_data(surface);
+        if (!top_down) {
+            data = data - (gross_pixels / height) * n_bytes_per_pixel * (height - 1);
+        }
+
+        return (new GlzDecodedSurface(image_id, image_win_head_id, data,
+                                      gross_pixels, n_bytes_per_pixel, surface));
+    }
+};
+
+/* TODO: unite with the window debug callbacks? */
+class GlzDecoderCanvasDebug: public GlzDecoderDebug {
+public:
+    virtual void error(const std::string& str)
+    {
+        throw Exception(str);
+    }
+
+    virtual void warn(const std::string& str)
+    {
+        LOG_WARN("%s", str.c_str());
+    }
+
+    virtual void info(const std::string& str)
+    {
+        LOG_INFO("%s", str.c_str());
+    }
+};
+
+class Canvas {
+public:
+    Canvas(PixmapCache& bits_cache, PaletteCache& palette_cache,
+           GlzDecoderWindow &glz_decoder_window);
+    virtual ~Canvas();
+
+    virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
+                             const PixmapHeader* pixmap) = 0;
+    virtual void copy_pixels(const QRegion& region, RedDrawable& dc) = 0;
+    virtual void thread_touch() = 0;
+
+    virtual void clear() = 0;
+
+    void draw_fill(RedFill& fill, int size);
+    void draw_text(RedText& text, int size);
+    void draw_opaque(RedOpaque& opaque, int size);
+    void draw_copy(RedCopy& copy, int size);
+    void draw_transparent(RedTransparent& transparent, int size);
+    void draw_alpha_blend(RedAlphaBlend& alpha_blend, int size);
+    void copy_bits(RedCopyBits& copy_bits, int size);
+    void draw_blend(RedBlend& blend, int size);
+    void draw_blackness(RedBlackness& blackness, int size);
+    void draw_whiteness(RedWhiteness& whiteness, int size);
+    void draw_invers(RedInvers& invers, int size);
+    void draw_rop3(RedRop3& rop3, int size);
+    void draw_stroke(RedStroke& stroke, int size);
+
+#ifdef WIN32
+    virtual void put_image(HDC dc, const PixmapHeader& image,
+                           const Rect& dest, const QRegion* clip) = 0;
+#else
+    virtual void put_image(const PixmapHeader& image, const Rect& dest,
+                           const QRegion* clip) = 0;
+#endif
+
+    virtual CanvasType get_pixmap_type() { return CANVAS_TYPE_INVALID; }
+
+protected:
+    virtual void set_access_params(ADDRESS delta, unsigned long base, unsigned long max) = 0;
+    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill) = 0;
+    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy) = 0;
+    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque) = 0;
+    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos) = 0;
+    virtual void draw_text(Rect *bbox, Clip *clip, Text *text) = 0;
+    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke) = 0;
+    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3) = 0;
+    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend) = 0;
+    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness) = 0;
+    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness) = 0;
+    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers) = 0;
+    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent) = 0;
+    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend) = 0;
+
+    PixmapCache& pixmap_cache() { return _pixmap_cache;}
+    PaletteCache& palette_cache() { return _palette_cache;}
+    static void bits_cache_put(void *opaque, uint64_t id, cairo_surface_t *surface);
+    static cairo_surface_t* bits_cache_get(void *opaque, uint64_t id);
+    static void palette_cache_put(void *opaque, Palette *palette);
+    static Palette* palette_cache_get(void *opaque, uint64_t id);
+    static void palette_cache_release(Palette* palette);
+
+    GlzDecoder& glz_decoder() {return _glz_decoder;}
+    static void glz_decode(void *opaque, uint8_t *data, Palette *plt, void *usr_data);
+
+private:
+    void access_test(void* ptr, size_t size);
+    void localalize_ptr(ADDRESS* data);
+    void localalize_image(ADDRESS* in_bitmap);
+    void localalize_brush(Brush& brush);
+    void localalize_attr(LineAttr& attr);
+    void localalize_mask(QMask& mask);
+    void begin_draw(RedDrawBase& base, int size, size_t min_size);
+
+private:
+    PixmapCache& _pixmap_cache;
+    PaletteCache& _palette_cache;
+
+    GlzDecodeSurfaceHandler _glz_handler;
+    GlzDecoderCanvasDebug _glz_debug;
+    GlzDecoder _glz_decoder;
+
+    unsigned long _base;
+    unsigned long _max;
+};
+
+
+#endif
+
diff --git a/client/canvas_utils.cpp b/client/canvas_utils.cpp
new file mode 100644
index 00000000..3210187b
--- /dev/null
+++ b/client/canvas_utils.cpp
@@ -0,0 +1,25 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "utils.h"
+
+
+#define CANVAS_ERROR(format, ...) THROW(format, ## __VA_ARGS__)
+
+#include "../common/canvas_utils.c"
+
diff --git a/client/cmd_line_parser.cpp b/client/cmd_line_parser.cpp
new file mode 100644
index 00000000..65ae404a
--- /dev/null
+++ b/client/cmd_line_parser.cpp
@@ -0,0 +1,524 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+
+#include <getopt.h>
+#include <iostream>
+
+#include "cmd_line_parser.h"
+#include "utils.h"
+#include "debug.h"
+
+#define DISABLE_ABBREVIATE
+
+
+CmdLineParser::Option::Option(int in_id, const std::string& in_name, char in_short_name,
+                              OptionType in_type, const std::string& in_help,
+                              const std::string& in_arg_name)
+    : id (in_id)
+    , name (in_name)
+    , arg_name (in_arg_name)
+    , type (in_type)
+    , short_name (in_short_name)
+    , help (in_help)
+    , optional (true)
+    , is_set (false)
+    , seperator (0)
+{
+}
+
+CmdLineParser::CmdLineParser(std::string description, bool allow_positional_args)
+    : _description (description)
+    , _short_options ("+")
+    , _argc (0)
+    , _argv (NULL)
+    , _multi_args (NULL)
+    , _multi_next (NULL)
+    , _multi_seperator (0)
+    , _positional_args (allow_positional_args)
+    , _done (false)
+{
+}
+
+CmdLineParser::~CmdLineParser()
+{
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        delete *iter;
+    }
+    delete[] _multi_args;
+}
+
+void CmdLineParser::add_private(int id, const std::string& name, char short_name,
+                                OptionType type, const std::string& help,
+                                const std::string& arg_name)
+{
+    if (_argv) {
+        THROW("unexpected");
+    }
+
+    if (find(id)) {
+        THROW("exist");
+    }
+
+    if (name.size() == 0) {
+        THROW("invalid name");
+    }
+
+    if (find(name)) {
+        THROW("name exist");
+    }
+
+    if (short_name != 0) {
+        if (!isalnum(short_name) || short_name == 'W') {
+            THROW("invalid short name");
+        }
+
+        if (find(short_name)) {
+            THROW("short name exist");
+        }
+    }
+
+    if (help.size() == 0) {
+        THROW("invalid help string");
+    }
+
+    if (help.find_first_of('\t') != std::string::npos) {
+        THROW("tab is not allow in help string");
+    }
+
+    _options.push_back(new Option(id, name, short_name, type, help, arg_name));
+}
+
+void CmdLineParser::add(int id, const std::string& name, const std::string& help, char short_name)
+{
+    if (id < OPTION_FIRST_AVILABLE) {
+        THROW("invalid id");
+    }
+    add_private(id, name, short_name, NO_ARGUMENT, help, "");
+}
+
+void CmdLineParser::add(int id, const std::string& name, const std::string& help,
+                        const std::string& arg_name, bool reqired_arg, char short_name)
+{
+    if (id < OPTION_FIRST_AVILABLE) {
+        THROW("invalid id");
+    }
+
+    if (arg_name.size() == 0) {
+        THROW("invalid arg name");
+    }
+
+    add_private(id, name, short_name, reqired_arg ? REQUIRED_ARGUMENT : OPTIONAL_ARGUMENT, help,
+                arg_name);
+}
+
+void CmdLineParser::set_multi(int id, char seperator)
+{
+    if (_argv) {
+        THROW("unexpected");
+    }
+
+    if (!ispunct(seperator)) {
+        THROW("invalid seperator");
+    }
+
+    Option* opt = find(id);
+
+    if (!opt) {
+        THROW("not found");
+    }
+
+    if (opt->type == NO_ARGUMENT) {
+        THROW("can't set multi for option without argument");
+    }
+
+    opt->seperator = seperator;
+}
+
+void CmdLineParser::set_reqired(int id)
+{
+    if (_argv) {
+        THROW("unexpected");
+    }
+
+    Option* opt = find(id);
+
+    if (!opt) {
+        THROW("not found");
+    }
+
+    opt->optional = false;
+}
+
+CmdLineParser::Option* CmdLineParser::find(int id)
+{
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        if ((*iter)->id == id) {
+            return *iter;
+        }
+    }
+    return NULL;
+}
+
+bool CmdLineParser::is_set(int id)
+{
+    Option *opt = find(id);
+
+    if (!opt) {
+        THROW("not found");
+    }
+    return opt->is_set;
+}
+
+CmdLineParser::Option* CmdLineParser::find(const std::string& name)
+{
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        if ((*iter)->name == name) {
+            return *iter;
+        }
+    }
+    return NULL;
+}
+
+CmdLineParser::Option* CmdLineParser::find(char short_name)
+{
+    if (short_name == 0) {
+        return NULL;
+    }
+
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        if ((*iter)->short_name == short_name) {
+            return *iter;
+        }
+    }
+    return NULL;
+}
+
+CmdLineParser::Option* CmdLineParser::find_missing_opt()
+{
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        CmdLineParser::Option* opt = *iter;
+        if (!opt->optional && !opt->is_set) {
+            return opt;
+        }
+    }
+    return NULL;
+}
+
+void CmdLineParser::build()
+{
+    Options::iterator iter = _options.begin();
+    _long_options.resize(_options.size() + 1);
+    for (int i = 0; iter != _options.end(); ++iter, i++) {
+        CmdLineParser::Option* opt = *iter;
+        struct option& long_option = _long_options[i];
+        long_option.name = opt->name.c_str();
+        switch (opt->type) {
+        case NO_ARGUMENT:
+            long_option.has_arg = no_argument;
+            break;
+        case OPTIONAL_ARGUMENT:
+            long_option.has_arg = optional_argument;
+            break;
+        case REQUIRED_ARGUMENT:
+            long_option.has_arg = required_argument;
+            break;
+        }
+        long_option.flag = &long_option.val;
+        long_option.val = opt->id;
+        if (opt->short_name != 0) {
+            _short_options += opt->short_name;
+            switch (opt->type) {
+            case OPTIONAL_ARGUMENT:
+                _short_options += "::";
+                break;
+            case REQUIRED_ARGUMENT:
+                _short_options += ":";
+                break;
+            case NO_ARGUMENT:
+                break;
+            }
+        }
+    }
+    struct option& long_option = _long_options[_long_options.size() - 1];
+    long_option.flag = 0;
+    long_option.has_arg = 0;
+    long_option.name = NULL;
+    long_option.val = 0;
+}
+
+void CmdLineParser::begin(int argc, char** argv)
+{
+    if (_argv) {
+        THROW("unexpected");
+    }
+
+    if (!argv || argc < 1) {
+        THROW("invalid args");
+    }
+
+    add_private(CmdLineParser::OPTION_HELP, "help", 0, NO_ARGUMENT, "show command help", "");
+    opterr = 0;
+    _argv = argv;
+    _argc = argc;
+    build();
+}
+
+char* CmdLineParser::start_multi(char *optarg, char seperator)
+{
+    if (!optarg) {
+        return NULL;
+    }
+    _multi_args = new char[strlen(optarg) + 1];
+    _multi_seperator = seperator;
+    strcpy(_multi_args, optarg);
+    if ((_multi_next = strchr(_multi_args, _multi_seperator))) {
+        *(_multi_next++) = 0;
+    }
+    return _multi_args;
+}
+
+char* CmdLineParser::next_multi()
+{
+    if (!_multi_next) {
+        _multi_seperator = 0;
+        delete[] _multi_args;
+        _multi_args = NULL;
+        return NULL;
+    }
+    char* ret = _multi_next;
+    if ((_multi_next = strchr(_multi_next, _multi_seperator))) {
+        *(_multi_next++) = 0;
+    }
+
+    return ret;
+}
+
+int CmdLineParser::get_option(char** val)
+{
+    CmdLineParser::Option* opt_obj;
+
+    if (!_argv) {
+        THROW("unexpected");
+    }
+
+    if (_multi_args) {
+        THROW("in multi args mode");
+    }
+
+    if (_done) {
+        THROW("is done");
+    }
+
+    int long_index;
+
+    int opt = getopt_long(_argc, _argv, _short_options.c_str(), &_long_options[0], &long_index);
+
+    switch (opt) {
+    case 0: {
+        if (!(opt_obj = find(_long_options[long_index].val))) {
+            THROW("long option no found");
+        }
+
+#ifdef DISABLE_ABBREVIATE
+        int name_pos = (opt_obj->type == REQUIRED_ARGUMENT) ? optind - 2 : optind - 1;
+        std::string cmd_name(_argv[name_pos] + 2);
+        if (cmd_name.find(opt_obj->name) != 0) {
+            std::cout << _argv[0] << ": invalid option '--" << cmd_name << "'\n";
+            return OPTION_ERROR;
+        }
+#endif
+
+        if (opt_obj->seperator) {
+            *val = start_multi(optarg, opt_obj->seperator);
+        } else {
+            *val = optarg;
+        }
+        opt_obj->is_set = true;
+        return opt_obj->id;
+    }
+    case -1: {
+        *val = NULL;
+        if (!_positional_args && optind != _argc) {
+            std::cout << _argv[0] << ": unexpected positional arguments\n";
+            return OPTION_ERROR;
+        }
+        if ((opt_obj = find_missing_opt())) {
+            std::cout << _argv[0] << ": option --" << opt_obj->name << " is required\n";
+            return OPTION_ERROR;
+        }
+        _done = true;
+        return OPTION_DONE;
+    }
+    case '?':
+        if (optopt >= 255) {
+            opt_obj = find(optopt);
+            ASSERT(opt_obj);
+
+#ifdef DISABLE_ABBREVIATE
+            std::string cmd_name(_argv[optind - 1] + 2);
+            if (cmd_name.find(opt_obj->name) != 0) {
+                std::cout << _argv[0] << ": invalid option '--" << cmd_name << "'\n";
+                return OPTION_ERROR;
+            }
+#endif
+            std::cout << _argv[0] << ": option --" << opt_obj->name << " requires an argument\n";
+        } else if (optopt == 0) {
+            std::cout << _argv[0] << ": invalid option '" << _argv[optind - 1] << "'\n";
+        } else if ((opt_obj = find((char)optopt))) {
+            std::cout << _argv[0] << ": option '-" << opt_obj->short_name <<
+                "' requires an argument\n";
+        } else {
+            std::cout << _argv[0] << ": invalid option '-" << char(optopt) << "'\n";
+        }
+        return OPTION_ERROR;
+    default:
+        if (opt > 255 || !(opt_obj = find((char)opt))) {
+            *val = NULL;
+            return OPTION_ERROR;
+        }
+        if (opt_obj->seperator) {
+            *val = start_multi(optarg, opt_obj->seperator);
+        } else {
+            *val = optarg;
+        }
+        opt_obj->is_set = true;
+        return opt_obj->id;
+    }
+}
+
+char* CmdLineParser::next_argument()
+{
+    if (!_argv) {
+        THROW("unexpected");
+    }
+
+    if (_multi_args) {
+        return next_multi();
+    }
+
+    if (!_done) {
+        THROW("not done");
+    }
+
+    if (optind == _argc) {
+        return NULL;
+    }
+    return _argv[optind++];
+}
+
+#ifdef WIN32
+char* basename(char *str)
+{
+    char *base;
+    if ((base = strrchr(str, '\\'))) {
+        return base;
+    }
+
+    if ((base = strrchr(str, ':'))) {
+        return base;
+    }
+    return str;
+}
+
+#endif
+
+void CmdLineParser::show_help()
+{
+    static const int HELP_START_POS = 30;
+    static const int HELP_WIDTH = 80 - HELP_START_POS;
+
+    std::cout << basename(_argv[0]) << " - " << _description.c_str() << "\n\noptions:\n\n";
+
+    Options::iterator iter = _options.begin();
+    for (; iter != _options.end(); ++iter) {
+        CmdLineParser::Option* opt = *iter;
+        std::ostringstream os;
+
+        if (opt->short_name) {
+            os << "  -" << opt->short_name << ", ";
+        } else {
+            os << "      ";
+        }
+
+        os << "--" << opt->name;
+
+        if (opt->type == OPTIONAL_ARGUMENT) {
+            os << "[=";
+        } else if (opt->type == REQUIRED_ARGUMENT) {
+            os << " <";
+        }
+
+        if (opt->type == OPTIONAL_ARGUMENT || opt->type == REQUIRED_ARGUMENT) {
+            if (opt->seperator) {
+                os << opt->arg_name << opt->seperator << opt->arg_name << "...";
+            } else {
+                os << opt->arg_name;
+            }
+        }
+
+        if (opt->type == OPTIONAL_ARGUMENT) {
+            os << "]";
+        } else if (opt->type == REQUIRED_ARGUMENT) {
+            os << ">";
+        }
+
+        int skip = HELP_START_POS - os.str().size();
+        if (skip < 2) {
+            os << "\n                              ";
+        } else {
+            while (skip--) {
+                os << " ";
+            }
+        }
+
+        int line_count = 0;
+        std::istringstream is(opt->help);
+        std::string line;
+        std::getline(is, line);
+        do {
+            if (line_count++) {
+                os << "                              ";
+            }
+            if (line.size() > HELP_WIDTH) {
+                int now = HELP_WIDTH;
+                std::string sub;
+                sub.append(line, 0, now);
+                int last_space;
+                if ((last_space = sub.find_last_of(' ')) != std::string::npos) {
+                    now = last_space;
+                    sub.resize(now++);
+                }
+                os << sub << "\n";
+                line = line.substr(now, line.size() - now);
+            } else {
+                os << line << "\n";
+                line.clear();
+            }
+        } while (line.size() || std::getline(is, line));
+
+        std::cout << os.str();
+    }
+    std::cout << "\n";
+}
+
diff --git a/client/cmd_line_parser.h b/client/cmd_line_parser.h
new file mode 100644
index 00000000..6b48e04a
--- /dev/null
+++ b/client/cmd_line_parser.h
@@ -0,0 +1,105 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CMD_LINE_PARSER
+#define _H_CMD_LINE_PARSER
+
+class CmdLineParser {
+public:
+
+    enum {
+        OPTION_ERROR = -1,
+        OPTION_DONE = 0,
+        OPTION_HELP = 256,
+        OPTION_FIRST_AVILABLE,
+    };
+
+    CmdLineParser(std::string description, bool allow_positional_args);
+    virtual ~CmdLineParser();
+
+    void add(int id, const std::string& name, const std::string& help,
+             char short_name = 0);
+
+    void add(int id, const std::string& name, const std::string& help,
+             const std::string& arg_name, bool reqired_arg, char short_name = 0);
+    void set_multi(int id, char seperator);
+    void set_reqired(int id);
+
+    void begin(int argc, char** argv);
+    int get_option(char** val);
+    char* next_argument();
+    bool is_set(int id);
+
+    void show_help();
+
+private:
+    class Option;
+
+    enum OptionType {
+        NO_ARGUMENT,
+        OPTIONAL_ARGUMENT,
+        REQUIRED_ARGUMENT,
+    };
+
+    void add_private(int id, const std::string& name, char short_name, OptionType type,
+                     const std::string& help, const std::string& arg_name);
+    Option* find(char short_name);
+    Option* find(int id);
+    Option* find(const std::string& name);
+    Option* find_missing_opt();
+
+    void build();
+
+    char* start_multi(char *optarg, char seperator);
+    char* next_multi();
+
+private:
+
+    class Option {
+    public:
+        Option(int in_id, const std::string& in_name, char in_short_name, OptionType in_type,
+               const std::string& in_help, const std::string& arg_name);
+
+    public:
+        int id;
+        std::string name;
+        std::string arg_name;
+        OptionType type;
+        char short_name;
+        std::string help;
+        bool optional;
+        bool is_set;
+        char seperator;
+    };
+
+    std::string _description;
+    std::vector<struct option> _long_options;
+    std::string _short_options;
+
+    typedef std::list<Option*> Options;
+    Options _options;
+    int _argc;
+    char** _argv;
+    char* _multi_args;
+    char* _multi_next;
+    char _multi_seperator;
+    bool _positional_args;
+    bool _done;
+};
+
+#endif
+
diff --git a/client/common.h b/client/common.h
new file mode 100644
index 00000000..69253db5
--- /dev/null
+++ b/client/common.h
@@ -0,0 +1,63 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_COMMON
+#define _H_COMMON
+
+#ifndef _WIN32_WCE
+#include <errno.h>
+#endif
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <exception>
+#include <list>
+#include <string.h>
+
+#ifdef WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <basetsd.h>
+
+#pragma warning(disable:4355)
+#pragma warning(disable:4996)
+#pragma warning(disable:4200)
+
+#define strcasecmp stricmp
+
+#else
+#include <unistd.h>
+#include <X11/X.h>
+#include <GL/glx.h>
+#endif
+
+#ifdef __GNUC__
+    #if __SIZEOF_POINTER__ == 8
+    #define RED64
+    #endif
+#elif defined(_WIN64)
+#define RED64
+#endif
+
+#include "red_types.h"
+
+#endif
+
diff --git a/client/cursor.cpp b/client/cursor.cpp
new file mode 100644
index 00000000..9bf8e9a6
--- /dev/null
+++ b/client/cursor.cpp
@@ -0,0 +1,113 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "cursor.h"
+#include "utils.h"
+#include "debug.h"
+
+CursorData::CursorData(RedCursor& cursor, int data_size)
+    : _atomic (1)
+    , _header (cursor.header)
+    , _data (NULL)
+    , _opaque (NULL)
+    , _local_cursor (NULL)
+{
+    int expected_size = 0;
+
+    switch (cursor.header.type) {
+    case CURSOR_TYPE_ALPHA:
+        expected_size = (_header.width << 2) * _header.height;
+        break;
+    case CURSOR_TYPE_MONO:
+        expected_size = (ALIGN(_header.width, 8) >> 2) * _header.height;
+        break;
+    case CURSOR_TYPE_COLOR4:
+        expected_size = (ALIGN(_header.width, 2) >> 1) * _header.height;
+        expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
+        expected_size += 16 * sizeof(uint32_t);
+        break;
+    case CURSOR_TYPE_COLOR8:
+        expected_size = _header.width * _header.height;
+        expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
+        expected_size += 256 * sizeof(uint32_t);
+        break;
+    case CURSOR_TYPE_COLOR16:
+        expected_size = (_header.width << 1) * _header.height;
+        expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
+        break;
+    case CURSOR_TYPE_COLOR24:
+        expected_size = (_header.width * 3) * _header.height;
+        expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
+        break;
+    case CURSOR_TYPE_COLOR32:
+        expected_size = (_header.width << 2) * _header.height;
+        expected_size += (ALIGN(_header.width, 8) >> 3) * _header.height;
+        break;
+    }
+
+    if (data_size < expected_size) {
+        THROW("access violation 0x%lx %u", (unsigned long)cursor.data, expected_size);
+    }
+    _data = new uint8_t[expected_size];
+    memcpy(_data, cursor.data, expected_size);
+}
+
+void CursorData::set_local(LocalCursor* local_cursor)
+{
+    ASSERT(!_local_cursor);
+    if (local_cursor) {
+        _local_cursor = local_cursor->ref();
+    }
+}
+
+CursorData::~CursorData()
+{
+    if (_local_cursor) {
+        _local_cursor->unref();
+    }
+    delete _opaque;
+    delete[] _data;
+}
+
+int LocalCursor::get_size_bits(const CursorHeader& header, int& size)
+{
+    switch (header.type) {
+    case CURSOR_TYPE_ALPHA:
+    case CURSOR_TYPE_COLOR32:
+        size = (header.width << 2) * header.height;
+        return 32;
+    case CURSOR_TYPE_MONO:
+        size = (ALIGN(header.width, 8) >> 3) * header.height;
+        return 1;
+    case CURSOR_TYPE_COLOR4:
+        size = (ALIGN(header.width, 2) >> 1) * header.height;
+        return 4;
+    case CURSOR_TYPE_COLOR8:
+        size = header.width * header.height;
+        return 8;
+    case CURSOR_TYPE_COLOR16:
+        size = (header.width << 1) * header.height;
+        return 16;
+    case CURSOR_TYPE_COLOR24:
+        size = (header.width * 3) * header.height;
+        return 24;
+    default:
+        return 0;
+    }
+}
+
diff --git a/client/cursor.h b/client/cursor.h
new file mode 100644
index 00000000..c964fd40
--- /dev/null
+++ b/client/cursor.h
@@ -0,0 +1,73 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CURSOR_
+#define _H_CURSOR_
+
+#include "threads.h"
+#include "red.h"
+#include "red_window_p.h"
+
+class CursorOpaque {
+public:
+    CursorOpaque() {}
+    virtual ~CursorOpaque() {}
+};
+
+class LocalCursor;
+
+class CursorData {
+public:
+    CursorData(RedCursor& cursor, int data_size);
+
+    CursorData *ref() { ++_atomic; return this;}
+    void unref() {if (--_atomic == 0) delete this;}
+    void set_opaque(CursorOpaque* opaque) { delete _opaque; _opaque = opaque;}
+    CursorOpaque* get_opaque() { return _opaque;}
+    void set_local(LocalCursor* local_cursor);
+    LocalCursor* get_local() { return _local_cursor;}
+    const CursorHeader& header() const { return _header;}
+    const uint8_t* data() const { return _data;}
+
+private:
+    ~CursorData();
+
+private:
+    AtomicCount _atomic;
+    CursorHeader _header;
+    uint8_t* _data;
+    CursorOpaque* _opaque;
+    LocalCursor* _local_cursor;
+};
+
+class LocalCursor {
+public:
+    LocalCursor(): _atomic (1) {}
+    virtual ~LocalCursor() {}
+    virtual void set(Window window) {}
+    LocalCursor* ref() { ++_atomic; return this;}
+    void unref() { if (--_atomic == 0) delete this;}
+
+protected:
+    static int get_size_bits(const CursorHeader& header, int &size);
+
+private:
+    AtomicCount _atomic;
+};
+
+#endif
+
diff --git a/client/cursor_channel.cpp b/client/cursor_channel.cpp
new file mode 100644
index 00000000..a78eba35
--- /dev/null
+++ b/client/cursor_channel.cpp
@@ -0,0 +1,661 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "cursor_channel.h"
+#include "cursor.h"
+#include "red_client.h"
+#include "application.h"
+#include "debug.h"
+#include "utils.h"
+#include "screen.h"
+#include "red_pixmap_cairo.h"
+#include "rect.h"
+
+static inline uint8_t revers_bits(uint8_t byte)
+{
+    uint8_t ret = 0;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        int shift = 7 - i * 2;
+        ret |= (byte & (1 << i)) << shift;
+        ret |= (byte & (0x80 >> i)) >> shift;
+    }
+    return ret;
+}
+
+class NaitivCursor: public CursorOpaque {
+public:
+    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area) = 0;
+};
+
+class AlphaCursor: public NaitivCursor {
+public:
+    AlphaCursor(const CursorHeader& header, const uint8_t* data);
+
+    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+
+private:
+    std::auto_ptr<RedPixmap> _pixmap;
+};
+
+class MonoCursor: public NaitivCursor {
+public:
+    MonoCursor(const CursorHeader& header, const uint8_t* data);
+
+    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+
+private:
+    std::auto_ptr<RedPixmap> _pixmap;
+    int _height;
+};
+
+class UnsupportedCursor: public NaitivCursor {
+public:
+    UnsupportedCursor(const CursorHeader& header);
+    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+
+private:
+    int _hot_x;
+    int _hot_y;
+};
+
+UnsupportedCursor::UnsupportedCursor(const CursorHeader& header)
+    : _hot_x (header.hot_spot_x)
+    , _hot_y (header.hot_spot_y)
+{
+    LOG_WARN("Unsupported cursor %hu", header.type);
+}
+
+void UnsupportedCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+{
+    Rect dest_area;
+    Rect rect;
+
+    dest_area.left = area.left;
+    dest_area.right = area.right;
+    dest_area.top = area.top;
+    dest_area.bottom = area.bottom;
+
+    rect.left = x + _hot_x - 2;
+    rect.right = rect.left + 8;
+    rect.top = y + _hot_y - 2;
+    rect.bottom = rect.top + 8;
+    rect_sect(rect, dest_area);
+
+    dest.fill_rect(rect, rgb32_make(0xf8, 0xf1, 0xb8));
+
+    rect.left = x + _hot_x - 1;
+    rect.right = rect.left + 6;
+    rect.top = y + _hot_y - 1;
+    rect.bottom = rect.top + 6;
+    rect_sect(rect, dest_area);
+
+    dest.frame_rect(rect, rgb32_make(0, 0, 0));
+}
+
+AlphaCursor::AlphaCursor(const CursorHeader& header, const uint8_t* data)
+    : _pixmap (new RedPixmapCairo(header.width, header.height,
+                                  RedPixmap::ARGB32, true, NULL, NULL))
+{
+    int stride = _pixmap->get_stride();
+    uint8_t* dest = _pixmap->get_data();
+    int line_size = header.width * sizeof(uint32_t);
+    for (int i = 0; i < header.height; i++, data += line_size, dest += stride) {
+        memcpy(dest, data, line_size);
+    }
+}
+
+void AlphaCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+{
+    dest.blend_pixels(*_pixmap, area.left - x, area.top - y, area);
+}
+
+MonoCursor::MonoCursor(const CursorHeader& header, const uint8_t* data)
+    : _pixmap (NULL)
+    , _height (header.height)
+{
+    rgb32_t pallete[2] = { rgb32_make(0x00, 0x00, 0x00), rgb32_make(0xff, 0xff, 0xff)};
+    _pixmap.reset(new RedPixmapCairo(header.width, _height * 2, RedPixmap::A1,
+                                     true, pallete, NULL));
+
+    int dest_stride = _pixmap->get_stride();
+    uint8_t *dest_line = _pixmap->get_data();
+    int src_stride = ALIGN(header.width, 8) >> 3;
+    const uint8_t* src_line = data;
+    const uint8_t* end_line = src_line + _pixmap->get_height() * src_stride;
+
+    if (_pixmap->is_big_endian_bits()) {
+        for (; src_line < end_line; src_line += src_stride, dest_line += dest_stride) {
+            memcpy(dest_line, src_line, src_stride);
+        }
+    } else {
+        for (; src_line < end_line; src_line += src_stride, dest_line += dest_stride) {
+            for (int i = 0; i < src_stride; i++) {
+                dest_line[i] = revers_bits(src_line[i]);
+            }
+        }
+    }
+}
+
+void MonoCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+{
+    dest.combine_pixels(*_pixmap, area.left - x, area.top - y, area, RedDrawable::OP_AND);
+    dest.combine_pixels(*_pixmap, area.left - x, area.top - y + _height, area, RedDrawable::OP_XOR);
+}
+
+class ColorCursor: public NaitivCursor {
+public:
+    ColorCursor(const CursorHeader& header);
+
+    virtual void draw(RedDrawable& dest, int x, int y, const Rect& area);
+
+protected:
+    void init_pixels(const CursorHeader& header, const uint8_t* _pixels, const uint8_t *and_mask);
+    virtual uint32_t get_pixel_color(const uint8_t *data, int row, int col) = 0;
+
+private:
+    std::auto_ptr<RedPixmap> _pixmap;
+    std::auto_ptr<RedPixmap> _invers;
+};
+
+ColorCursor::ColorCursor(const CursorHeader& header)
+    : _pixmap (new RedPixmapCairo(header.width, header.height,
+                                  RedPixmap::ARGB32, true, NULL, NULL))
+    , _invers (NULL)
+{
+    rgb32_t pallete[2] = { rgb32_make(0x00, 0x00, 0x00), rgb32_make(0xff, 0xff, 0xff)};
+    _invers.reset(new RedPixmapCairo(header.width, header.height, RedPixmap::A1,
+                                     true, pallete, NULL));
+}
+
+void ColorCursor::init_pixels(const CursorHeader& header, const uint8_t* pixels,
+                              const uint8_t *and_mask)
+{
+    int mask_stride = ALIGN(header.width, 8) / 8;
+    int invers_stride = _invers->get_stride();
+    int pixmap_stride = _pixmap->get_stride();
+    uint8_t *_pixmap_line = _pixmap->get_data();
+    uint8_t* invers_line = _invers->get_data();
+    bool be_bits = _invers->is_big_endian_bits();
+    memset(invers_line, 0, header.height * invers_stride);
+    for (int i = 0; i < header.height; i++, and_mask += mask_stride, invers_line += invers_stride,
+                                            _pixmap_line += pixmap_stride) {
+        uint32_t *line_32 = (uint32_t *)_pixmap_line;
+        for (int j = 0; j < header.width; j++) {
+            uint32_t pixel_val = get_pixel_color(pixels, i, j);
+            int and_val = test_bit_be(and_mask, j);
+            if ((pixel_val & 0x00ffffff) == 0 && and_val) {
+                line_32[j] = 0;
+            } else if ((pixel_val & 0x00ffffff) == 0x00ffffff && and_val) {
+                line_32[j] = 0;
+                if (be_bits) {
+                    set_bit_be(invers_line, j);
+                } else {
+                    set_bit(invers_line, j);
+                }
+            } else {
+                line_32[j] = pixel_val | 0xff000000;
+            }
+        }
+    }
+}
+
+void ColorCursor::draw(RedDrawable& dest, int x, int y, const Rect& area)
+{
+    dest.blend_pixels(*_pixmap, area.left - x, area.top - y, area);
+    dest.combine_pixels(*_invers, area.left - x, area.top - y, area, RedDrawable::OP_XOR);
+}
+
+class ColorCursor32: public ColorCursor {
+public:
+    ColorCursor32(const CursorHeader& header, const uint8_t* data)
+        : ColorCursor(header)
+        , _src_stride (header.width * sizeof(uint32_t))
+    {
+        init_pixels(header, data, data + _src_stride * header.height);
+    }
+
+private:
+    uint32_t get_pixel_color(const uint8_t *data, int row, int col)
+    {
+        return *((uint32_t *)(data + row * _src_stride) + col);
+    }
+
+private:
+    int _src_stride;
+};
+
+class ColorCursor16: public ColorCursor {
+public:
+    ColorCursor16(const CursorHeader& header, const uint8_t* data)
+        : ColorCursor(header)
+        , _src_stride (header.width * sizeof(uint16_t))
+    {
+        init_pixels(header, data, data + _src_stride * header.height);
+    }
+
+private:
+    uint32_t get_pixel_color(const uint8_t *data, int row, int col)
+    {
+        uint32_t pix = *((uint16_t*)(data + row * _src_stride) + col);
+        return ((pix & 0x1f) << 3) | ((pix & 0x3e0) << 6) | ((pix & 0x7c00) << 9);
+    }
+
+private:
+    int _src_stride;
+};
+
+class ColorCursor4: public ColorCursor {
+public:
+    ColorCursor4(const CursorHeader& header, const uint8_t* data)
+        : ColorCursor(header)
+        , _src_stride (ALIGN(header.width, 2) >> 1)
+        , _palette ((uint32_t*)(data + _src_stride * header.height))
+    {
+        init_pixels(header, data, (uint8_t*)(_palette + 16));
+    }
+
+private:
+    uint32_t get_pixel_color(const uint8_t *data, int row, int col)
+    {
+        data += _src_stride * row + (col >> 1);
+        return (col & 1) ? _palette[*data & 0x0f] : _palette[*data >> 4];
+    }
+
+private:
+    int _src_stride;
+    uint32_t* _palette;
+};
+
+class CursorSetEvent: public Event {
+public:
+    CursorSetEvent(CursorChannel& channel, CursorData *cursor, int x, int y, bool visable)
+        : _channel (channel)
+        , _cursor (cursor->ref())
+        , _x (x)
+        , _y (y)
+        , _visible (visable)
+    {
+    }
+
+    void create_cursor()
+    {
+        CursorData *cursor = *_cursor;
+        CursorOpaque* native_cursor = cursor->get_opaque();
+
+        if (native_cursor) {
+            return;
+        }
+
+        switch (cursor->header().type) {
+        case CURSOR_TYPE_ALPHA:
+            native_cursor = new AlphaCursor(cursor->header(), cursor->data());
+            break;
+        case CURSOR_TYPE_COLOR32:
+            native_cursor = new ColorCursor32(cursor->header(), cursor->data());
+            break;
+        case CURSOR_TYPE_MONO:
+            native_cursor = new MonoCursor(cursor->header(), cursor->data());
+            break;
+        case CURSOR_TYPE_COLOR4:
+            native_cursor = new ColorCursor4(cursor->header(), cursor->data());
+            break;
+        case CURSOR_TYPE_COLOR8:
+            native_cursor = new UnsupportedCursor(cursor->header());
+            break;
+        case CURSOR_TYPE_COLOR16:
+            native_cursor = new ColorCursor16(cursor->header(), cursor->data());
+            break;
+        case CURSOR_TYPE_COLOR24:
+            native_cursor = new UnsupportedCursor(cursor->header());
+            break;
+        default:
+            THROW("invalid curosr type");
+        }
+        cursor->set_opaque(native_cursor);
+    }
+
+    virtual void responce(Application& application)
+    {
+        CursorData *cursor = *_cursor;
+        create_cursor();
+        Lock lock(_channel._update_lock);
+
+        _channel._hot_pos.x = _x;
+        _channel._hot_pos.y = _y;
+        _channel._cursor_visible = _visible;
+        _channel._cursor_rect.left = _x - cursor->header().hot_spot_x;
+        _channel._cursor_rect.right = _channel._cursor_rect.left + cursor->header().width;
+        _channel._cursor_rect.top = _y - cursor->header().hot_spot_y;
+        _channel._cursor_rect.bottom = _channel._cursor_rect.top + cursor->header().height;
+
+        if (application.get_mouse_mode() == RED_MOUSE_MODE_CLIENT) {
+            RedScreen* screen = _channel.screen();
+            ASSERT(screen);
+            screen->set_cursor(_visible ? cursor : NULL);
+        } else {
+            if (_visible) {
+                _channel.set_rect_area(_channel._cursor_rect);
+            } else {
+                _channel.clear_area();
+            }
+        }
+
+        if (_channel._cursor) {
+            _channel._cursor->unref();
+        }
+
+        _channel._cursor = cursor->ref();
+    }
+
+private:
+    CursorChannel& _channel;
+    AutoRef<CursorData> _cursor;
+    int _x;
+    int _y;
+    bool _visible;
+};
+
+class CursorMoveEvent: public Event {
+public:
+    CursorMoveEvent(CursorChannel& channel, int x, int y)
+        : _channel (channel)
+        , _x (x)
+        , _y (y)
+    {
+    }
+
+    virtual void responce(Application& application)
+    {
+        _channel._cursor_visible = true;
+        if (application.get_mouse_mode() == RED_MOUSE_MODE_CLIENT) {
+            RedScreen* screen = _channel.screen();
+            ASSERT(screen);
+            screen->set_cursor(_channel._cursor);
+        } else {
+            Lock lock(_channel._update_lock);
+            int dx = _x - _channel._hot_pos.x;
+            int dy = _y - _channel._hot_pos.y;
+            _channel._hot_pos.x += dx;
+            _channel._hot_pos.y += dy;
+            _channel._cursor_rect.left += dx;
+            _channel._cursor_rect.right += dx;
+            _channel._cursor_rect.top += dy;
+            _channel._cursor_rect.bottom += dy;
+            lock.unlock();
+            _channel.set_rect_area(_channel._cursor_rect);
+        }
+    }
+
+private:
+    CursorChannel& _channel;
+    int _x;
+    int _y;
+};
+
+class CursorHideEvent: public Event {
+public:
+    CursorHideEvent(CursorChannel& channel): _channel (channel) {}
+    virtual void responce(Application& application)
+    {
+        _channel._cursor_visible = false;
+        if (application.get_mouse_mode() == RED_MOUSE_MODE_CLIENT) {
+            RedScreen* screen = _channel.screen();
+            ASSERT(screen);
+            screen->set_cursor(NULL);
+        } else {
+            _channel.clear_area();
+        }
+    }
+
+private:
+    CursorChannel& _channel;
+};
+
+class CursorRemoveEvent: public Event {
+public:
+    CursorRemoveEvent(CursorChannel& channel): _channel (channel) {}
+    virtual void responce(Application& application)
+    {
+        _channel._cursor_visible = false;
+        _channel.clear_area();
+        if (_channel._cursor) {
+            _channel._cursor->unref();
+            _channel._cursor = NULL;
+        }
+    }
+
+private:
+    CursorChannel& _channel;
+};
+
+class CursorHandler: public MessageHandlerImp<CursorChannel, RED_CURSOR_MESSAGES_END> {
+public:
+    CursorHandler(CursorChannel& channel)
+        : MessageHandlerImp<CursorChannel, RED_CURSOR_MESSAGES_END>(channel) {}
+};
+
+class CursorModeEvent: public Event {
+public:
+    CursorModeEvent(CursorChannel& channel): _channel (channel) {}
+
+    virtual void responce(Application& application)
+    {
+        RedScreen* screen = _channel.screen();
+        if (!screen) {
+            return;
+        }
+        if (application.get_mouse_mode() == RED_MOUSE_MODE_CLIENT) {
+            _channel.clear_area();
+            screen->set_cursor(_channel._cursor_visible ? _channel._cursor : NULL);
+        } else {
+            if (_channel._cursor_visible && _channel._cursor) {
+                _channel.set_rect_area(_channel._cursor_rect);
+            } else {
+                _channel.clear_area();
+            }
+        }
+        screen->relase_inputs();
+    }
+
+private:
+    CursorChannel& _channel;
+};
+
+CursorModeTrigger::CursorModeTrigger(CursorChannel& channel)
+    : _channel (channel)
+{
+}
+
+void CursorModeTrigger::on_event()
+{
+    AutoRef<CursorModeEvent> set_event(new CursorModeEvent(_channel));
+    _channel.get_client().push_event(*set_event);
+}
+
+CursorChannel::CursorChannel(RedClient& client, uint32_t id)
+    : RedChannel(client, RED_CHANNEL_CURSOR, id, new CursorHandler(*this))
+    , ScreenLayer(SCREEN_LAYER_CURSOR, false)
+    , _cursor (NULL)
+    , _cursor_trigger (*this)
+    , _cursor_visible (false)
+{
+    CursorHandler* handler = static_cast<CursorHandler*>(get_message_handler());
+
+    handler->set_handler(RED_MIGRATE, &CursorChannel::handle_migrate, 0);
+    handler->set_handler(RED_SET_ACK, &CursorChannel::handle_set_ack, sizeof(RedSetAck));
+    handler->set_handler(RED_PING, &CursorChannel::handle_ping, sizeof(RedPing));
+    handler->set_handler(RED_WAIT_FOR_CHANNELS, &CursorChannel::handle_wait_for_channels,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISCONNECTING, &CursorChannel::handle_disconnect,
+                         sizeof(RedDisconnect));
+    handler->set_handler(RED_NOTIFY, &CursorChannel::handle_notify, sizeof(RedNotify));
+
+    handler->set_handler(RED_CURSOR_INIT, &CursorChannel::handle_init, sizeof(RedCursorInit));
+    handler->set_handler(RED_CURSOR_RESET, &CursorChannel::handle_reset, 0);
+    handler->set_handler(RED_CURSOR_SET, &CursorChannel::handle_cursor_set,
+                         sizeof(RedCursorSet));
+    handler->set_handler(RED_CURSOR_MOVE, &CursorChannel::handle_cursor_move,
+                         sizeof(RedCursorMove));
+    handler->set_handler(RED_CURSOR_HIDE, &CursorChannel::handle_cursor_hide, 0);
+    handler->set_handler(RED_CURSOR_TRAIL, &CursorChannel::handle_cursor_trail,
+                         sizeof(RedCursorTrail));
+    handler->set_handler(RED_CURSOR_INVAL_ONE, &CursorChannel::handle_inval_one,
+                         sizeof(RedInvalOne));
+    handler->set_handler(RED_CURSOR_INVAL_ALL, &CursorChannel::handle_inval_all, 0);
+
+    get_events_loop().add_trigger(_cursor_trigger);
+}
+
+CursorChannel::~CursorChannel()
+{
+    ASSERT(!_cursor);
+}
+
+void CursorChannel::on_connect()
+{
+}
+
+void CursorChannel::on_disconnect()
+{
+    remove_cursor();
+    _cursor_cache.clear();
+    AutoRef<SyncEvent> sync_event(new SyncEvent());
+    get_client().push_event(*sync_event);
+    (*sync_event)->wait();
+    detach_from_screen(get_client().get_application());
+}
+
+void CursorChannel::remove_cursor()
+{
+    AutoRef<CursorRemoveEvent> event(new CursorRemoveEvent(*this));
+    get_client().push_event(*event);
+}
+
+void CursorChannel::copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc)
+{
+    Lock lock(_update_lock);
+    for (int i = 0; i < (int)dest_region.num_rects; i++) {
+        ASSERT(_cursor && _cursor->get_opaque());
+        ((NaitivCursor*)_cursor->get_opaque())->draw(dest_dc, _cursor_rect.left, _cursor_rect.top,
+                                                     dest_region.rects[i]);
+    }
+}
+
+void CursorChannel::set_cursor(RedCursor& red_cursor, int data_size, int x, int y, bool visible)
+{
+    CursorData *cursor;
+
+    if (red_cursor.flags & RED_CURSOR_NONE) {
+        remove_cursor();
+        return;
+    }
+
+    if (red_cursor.flags & RED_CURSOR_FROM_CACHE) {
+        cursor = _cursor_cache.get(red_cursor.header.unique);
+    } else {
+        cursor = new CursorData(red_cursor, data_size);
+        if (red_cursor.flags & RED_CURSOR_CACHE_ME) {
+            ASSERT(red_cursor.header.unique);
+            _cursor_cache.add(red_cursor.header.unique, cursor);
+        }
+    }
+
+    AutoRef<CursorData> cursor_ref(cursor);
+    AutoRef<CursorSetEvent> set_event(new CursorSetEvent(*this, *cursor_ref, x, y, visible));
+    get_client().push_event(*set_event);
+}
+
+void CursorChannel::handle_init(RedPeer::InMessage *message)
+{
+    RedCursorInit *init = (RedCursorInit*)message->data();
+    attach_to_screen(get_client().get_application(), get_id());
+    remove_cursor();
+    _cursor_cache.clear();
+    set_cursor_mode();
+    set_cursor(init->cursor, message->size() - sizeof(RedCursorInit), init->position.x,
+               init->position.y, init->visible != 0);
+}
+
+void CursorChannel::handle_reset(RedPeer::InMessage *message)
+{
+    remove_cursor();
+    detach_from_screen(get_client().get_application());
+    _cursor_cache.clear();
+}
+
+void CursorChannel::handle_cursor_set(RedPeer::InMessage* message)
+{
+    RedCursorSet* set = (RedCursorSet*)message->data();
+    set_cursor(set->cursor, message->size() - sizeof(RedCursorSet), set->postition.x,
+               set->postition.y, set->visible != 0);
+}
+
+void CursorChannel::handle_cursor_move(RedPeer::InMessage* message)
+{
+    RedCursorMove* move = (RedCursorMove*)message->data();
+    AutoRef<CursorMoveEvent> event(new CursorMoveEvent(*this, move->postition.x,
+                                                       move->postition.y));
+    get_client().push_event(*event);
+}
+
+void CursorChannel::handle_cursor_hide(RedPeer::InMessage* message)
+{
+    AutoRef<CursorHideEvent> event(new CursorHideEvent(*this));
+    get_client().push_event(*event);
+}
+
+void CursorChannel::handle_cursor_trail(RedPeer::InMessage* message)
+{
+    RedCursorTrail* trail = (RedCursorTrail*)message->data();
+    DBG(0, "length %u frequency %u", trail->length, trail->frequency)
+}
+
+void CursorChannel::handle_inval_one(RedPeer::InMessage* message)
+{
+    RedInvalOne* inval = (RedInvalOne*)message->data();
+    _cursor_cache.remove(inval->id);
+}
+
+void CursorChannel::handle_inval_all(RedPeer::InMessage* message)
+{
+    _cursor_cache.clear();
+}
+
+void CursorChannel::set_cursor_mode()
+{
+    _cursor_trigger.trigger();
+}
+
+class CursorFactory: public ChannelFactory {
+public:
+    CursorFactory() : ChannelFactory(RED_CHANNEL_CURSOR) {}
+    virtual RedChannel* construct(RedClient& client, uint32_t id)
+    {
+        return new CursorChannel(client, id);
+    }
+};
+
+static CursorFactory factory;
+
+ChannelFactory& CursorChannel::Factory()
+{
+    return factory;
+}
+
diff --git a/client/cursor_channel.h b/client/cursor_channel.h
new file mode 100644
index 00000000..830b57f1
--- /dev/null
+++ b/client/cursor_channel.h
@@ -0,0 +1,100 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CURSOR_CHANNEL
+#define _H_CURSOR_CHANNEL
+
+#include "red_channel.h"
+#include "cache.hpp"
+#include "cursor.h"
+#include "screen_layer.h"
+
+class ChannelFactory;
+class CursorChannel;
+
+class CursorCacheTreat {
+public:
+    static inline CursorData* get(CursorData* cursor)
+    {
+        return cursor->ref();
+    }
+
+    static inline void release(CursorData* cursor)
+    {
+        cursor->unref();
+    }
+
+    static const char* name() { return "cursor";}
+};
+
+typedef Cache<CursorData, CursorCacheTreat, 1024> CursorCache;
+
+class CursorModeTrigger: public EventsLoop::Trigger {
+public:
+    CursorModeTrigger(CursorChannel& channel);
+    virtual void on_event();
+
+private:
+    CursorChannel& _channel;
+};
+
+class CursorChannel: public RedChannel, public ScreenLayer {
+public:
+    CursorChannel(RedClient& client, uint32_t id);
+    virtual ~CursorChannel();
+
+    static ChannelFactory& Factory();
+    void set_cursor_mode();
+
+protected:
+    virtual void on_connect();
+    virtual void on_disconnect();
+
+private:
+    void set_cursor(RedCursor& red_cursor, int data_size, int x, int y, bool visible);
+    void remove_cursor();
+
+    virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc);
+
+    void handle_init(RedPeer::InMessage* message);
+    void handle_reset(RedPeer::InMessage* message);
+    void handle_cursor_set(RedPeer::InMessage* message);
+    void handle_cursor_move(RedPeer::InMessage* message);
+    void handle_cursor_hide(RedPeer::InMessage* message);
+    void handle_cursor_trail(RedPeer::InMessage* message);
+    void handle_inval_one(RedPeer::InMessage* message);
+    void handle_inval_all(RedPeer::InMessage* message);
+
+    friend class CursorSetEvent;
+    friend class CursorMoveEvent;
+    friend class CursorHideEvent;
+    friend class CursorRemoveEvent;
+    friend class CursorModeTrigger;
+    friend class CursorModeEvent;
+
+private:
+    CursorCache _cursor_cache;
+    CursorData* _cursor;
+    CursorModeTrigger _cursor_trigger;
+    Point _hot_pos;
+    Rect _cursor_rect;
+    Mutex _update_lock;
+    bool _cursor_visible;
+};
+
+#endif
+
diff --git a/client/debug.h b/client/debug.h
new file mode 100644
index 00000000..cf84296c
--- /dev/null
+++ b/client/debug.h
@@ -0,0 +1,101 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_DEBUG
+#define _H_DEBUG
+
+#include <stdlib.h>
+#include <sstream>
+
+#include <log4cpp/Category.hh>
+#include <log4cpp/convenience.h>
+
+#ifdef WIN32
+#define snprintf _snprintf
+#endif
+
+#define ON_PANIC() ::abort()
+
+#ifdef RED_DEBUG
+
+#ifdef WIN32
+#define ASSERTBREAK DebugBreak()
+#else
+#define ASSERTBREAK ::abort()
+#endif
+
+#define ASSERT(x) if (!(x)) {                               \
+    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
+    ASSERTBREAK;                                            \
+}
+
+#else
+
+#define ASSERT(cond)
+
+#endif
+
+#ifdef __GNUC__
+static inline std::string pretty_func_to_func_name(const std::string& f_name)
+{
+    std::string name(f_name);
+    std::string::size_type end_pos = f_name.find('(');
+    if (end_pos == std::string::npos) {
+        return f_name;
+    }
+    std::string::size_type start = f_name.rfind(' ', end_pos);
+    if (start == std::string::npos) {
+        return f_name;
+    }
+    end_pos -= ++start;
+    return name.substr(start, end_pos);
+}
+
+#define FUNC_NAME pretty_func_to_func_name(__PRETTY_FUNCTION__).c_str()
+#else
+#define FUNC_NAME __FUNCTION__
+#endif
+
+#define LOGGER_SECTION(section) LOG4CPP_LOGGER(section)
+
+LOG4CPP_LOGGER("spice")
+
+#define LOG(type, format, ...) {                                                \
+    std::string log_message;                                                    \
+    string_printf(log_message, "%s: " format, FUNC_NAME, ## __VA_ARGS__);       \
+    LOG4CPP_##type(logger, log_message.c_str());                                \
+}
+
+#define LOG_INFO(format, ...) LOG(INFO, format, ## __VA_ARGS__)
+#define LOG_WARN(format, ...) LOG(WARN, format, ## __VA_ARGS__)
+#define LOG_ERROR(format, ...) LOG(ERROR, format, ## __VA_ARGS__)
+
+#define PANIC(format, ...) {                \
+    LOG(FATAL, format, ## __VA_ARGS__);     \
+    ON_PANIC();                             \
+}
+
+#define DBGLEVEL 1000
+
+#define DBG(level, format, ...) {               \
+    if (level <= DBGLEVEL) {                    \
+        LOG(DEBUG, format, ## __VA_ARGS__);     \
+    }                                           \
+}
+
+#endif // _H_DEBUG
+
diff --git a/client/display_channel.cpp b/client/display_channel.cpp
new file mode 100644
index 00000000..5412e7f2
--- /dev/null
+++ b/client/display_channel.cpp
@@ -0,0 +1,1483 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+
+#include "common.h"
+#include "canvas.h"
+#include "red_pixmap.h"
+#ifdef USE_OGL
+#include "red_pixmap_gl.h"
+#endif
+#include "debug.h"
+#include "utils.h"
+#include "common.h"
+#include "display_channel.h"
+#include "application.h"
+#include "screen.h"
+#ifdef USE_OGL
+#include "red_gl_canvas.h"
+#endif
+#include "red_cairo_canvas.h"
+#include "red_client.h"
+#include "utils.h"
+#include "debug.h"
+#ifdef WIN32
+#include "red_gdi_canvas.h"
+#endif
+#include "platform_utils.h"
+
+extern "C" {
+#include "libavcodec/avcodec.h"
+}
+
+static Mutex avcodec_mutex;
+
+class SetModeEvent: public SyncEvent {
+public:
+    SetModeEvent(DisplayChannel& channel, int width, int height, int depth)
+        : _channel (channel)
+        , _width (width)
+        , _height (height)
+        , _depth (depth)
+    {
+    }
+
+    virtual void do_responce(Application& application)
+    {
+        _channel.screen()->set_mode(_width, _height, _depth);
+    }
+
+private:
+    DisplayChannel& _channel;
+    int _width;
+    int _height;
+    int _depth;
+};
+
+class DisplayMarkEvent: public Event {
+public:
+    DisplayMarkEvent(int screen_id)
+        : _screen_id (screen_id)
+    {
+    }
+
+    virtual void responce(Application& application)
+    {
+        application.hide_splash(_screen_id);
+    }
+
+private:
+    int _screen_id;
+};
+
+#define CLIP_ARRAY_SIZE 1500
+#define CLIP_ARRAY_SHIFT 500
+
+static uint8_t clip_array[CLIP_ARRAY_SIZE];
+static uint8_t *clip_zero = &clip_array[CLIP_ARRAY_SHIFT];
+
+static void init_clip_array()
+{
+    int i;
+    for (i = 0; i < CLIP_ARRAY_SHIFT; i++) {
+        clip_array[i] = 0;
+    }
+
+    for (i = CLIP_ARRAY_SHIFT + 256; i < CLIP_ARRAY_SIZE; i++) {
+        clip_array[i] = 0xff;
+    }
+
+    for (i = 0; i < 256; i++) {
+        clip_zero[i] = i;
+    }
+}
+
+#define  CLIP(val) clip_zero[(int)(val)]
+
+#define R(pixel) (((uint8_t*)(pixel))[0])
+#define G(pixel) (((uint8_t*)(pixel))[1])
+#define B(pixel) (((uint8_t*)(pixel))[2])
+
+#define YUV_TO_RGB(pixel, y, u , v) {                           \
+    int Y = (y) - 16;                                           \
+    int U = (u) - 128;                                          \
+    int V = (v) - 128;                                          \
+    R(pixel) = CLIP((298 * Y + 409 * V + 128) >> 8);            \
+    G(pixel) = CLIP((298 * Y - 100 * U - 208 * V + 128) >> 8);  \
+    B(pixel) = CLIP((298 * Y + 516 * U + 128) >> 8);            \
+}
+
+static inline void yuv420_to_rgb(AVFrame* frame, uint8_t* data, uint32_t width, uint32_t height,
+                                 int stride, int top_down)
+{
+    ASSERT(width % 2 == 0);
+    ASSERT(height % 2 == 0);
+
+    if (top_down) {
+        data += stride * height - 1;
+        stride = -stride;
+    }
+
+    // B = 1.164(Y - 16) + 2.018(U - 128)
+    // G = 1.164(Y - 16) - 0.813(V - 128) - 0.391(U - 128)
+    // R = 1.164(Y - 16) + 1.596(V - 128)
+
+    uint8_t* y_line = frame->data[0];
+    uint8_t* u = frame->data[1];
+    uint8_t* v = frame->data[2];
+
+    uint32_t y_stride = frame->linesize[0];
+    uint32_t u_stride = frame->linesize[1];
+    uint32_t v_stride = frame->linesize[2];
+
+    for (unsigned int i = 0; i < height / 2; i++) {
+        uint8_t* now = data;
+        uint8_t* y = y_line;
+
+        for (unsigned int j = 0; j < width / 2; j++) {
+            YUV_TO_RGB(now, *y, u[j], v[j]);
+            YUV_TO_RGB(now + sizeof(uint32_t), *(y + 1), u[j], v[j]);
+            YUV_TO_RGB(now + stride, *(y + y_stride), u[j], v[j]);
+            YUV_TO_RGB(now + stride + sizeof(uint32_t), *(y + y_stride + 1), u[j], v[j]);
+            y += 2;
+            now += 2 * sizeof(uint32_t);
+        }
+        data += stride * 2;
+        y_line += y_stride * 2;
+        u += u_stride;
+        v += v_stride;
+    }
+}
+
+#define MAX_VIDEO_FRAMES 30
+#define MAX_OVER 15
+#define MAX_UNDER -15
+
+
+class VideoStream {
+public:
+    VideoStream(RedClient& client, Canvas& canvas, DisplayChannel& channel,
+                uint32_t codec_type, bool top_down, uint32_t stream_width,
+                uint32_t stream_height, uint32_t src_width, uint32_t src_height,
+                Rect* dest, int clip_type, uint32_t num_clip_rects, Rect* clip_rects);
+    ~VideoStream();
+
+    void push_data(uint32_t mm_time, uint32_t length, uint8_t* data, uint32_t ped_size);
+    void set_clip(int type, uint32_t num_clip_rects, Rect* clip_rects);
+    const Rect& get_dest() {return _dest;}
+    void handle_update_mark(uint64_t update_mark);
+    uint32_t handle_timer_update(uint32_t now);
+
+    static void init();
+
+private:
+    void free_frame(uint32_t frame_index);
+    void release_all_bufs();
+    void remove_dead_frames(uint32_t mm_time);
+    uint32_t alloc_frame_slot();
+    void maintenance();
+    void drop_one_frame();
+    uint32_t frame_slot(uint32_t frame_index) { return frame_index % MAX_VIDEO_FRAMES;}
+    static bool is_time_to_display(uint32_t now, uint32_t frame_time);
+
+private:
+    RedClient& _client;
+    Canvas& _canvas;
+    DisplayChannel& _channel;
+    AVCodecContext* _ctx;
+    AVFrame* _frame;
+    int _stream_width;
+    int _stream_height;
+    int _stride;
+    bool _top_down;
+    Rect _dest;
+    QRegion _clip_region;
+    QRegion* _clip;
+
+    struct VideoFrame {
+        uint32_t mm_time;
+        uint32_t compressed_data_size;
+        uint8_t* compressed_data;
+    };
+
+    uint32_t _frames_head;
+    uint32_t _frames_tail;
+    uint32_t _kill_mark;
+    VideoFrame _frames[MAX_VIDEO_FRAMES];
+
+#ifdef WIN32
+    HBITMAP _prev_bitmap;
+    HDC _dc;
+#endif
+    uint8_t *_uncompressed_data;
+    PixmapHeader _pixmap;
+    uint64_t _update_mark;
+    uint32_t _update_time;
+
+public:
+    VideoStream* next;
+};
+
+#ifdef WIN32
+static int create_bitmap(HDC *dc, HBITMAP *prev_bitmap,
+                         uint8_t **data, int *nstride,
+                         int width, int height)
+{
+    HBITMAP bitmap;
+    struct {
+        BITMAPINFO inf;
+        RGBQUAD palette[255];
+    } bitmap_info;
+
+    memset(&bitmap_info, 0, sizeof(bitmap_info));
+    bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+    bitmap_info.inf.bmiHeader.biWidth = width;
+    bitmap_info.inf.bmiHeader.biHeight = height;
+
+    bitmap_info.inf.bmiHeader.biPlanes = 1;
+    bitmap_info.inf.bmiHeader.biBitCount = 32;
+    bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+    *nstride = width * 4;
+
+    *dc = create_compatible_dc();
+    if (!*dc) {
+        return 0;
+    }
+
+    bitmap = CreateDIBSection(*dc, &bitmap_info.inf, 0, (void **)data, NULL, 0);
+    if (!bitmap) {
+        DeleteObject(*dc);
+        return 0;
+    }
+
+    *prev_bitmap = (HBITMAP)SelectObject(*dc, bitmap);
+    return 1;
+}
+
+#endif
+
+VideoStream::VideoStream(RedClient& client, Canvas& canvas, DisplayChannel& channel,
+                         uint32_t codec_type, bool top_down, uint32_t stream_width,
+                         uint32_t stream_height, uint32_t src_width, uint32_t src_height,
+                         Rect* dest, int clip_type, uint32_t num_clip_rects,
+                         Rect* clip_rects)
+    : _client (client)
+    , _canvas (canvas)
+    , _channel (channel)
+    , _ctx (NULL)
+    , _frame (NULL)
+    , _stream_width (stream_width)
+    , _stream_height (stream_height)
+    , _stride (stream_width * sizeof(uint32_t))
+    , _top_down (top_down)
+    , _dest (*dest)
+    , _clip (NULL)
+    , _frames_head (0)
+    , _frames_tail (0)
+    , _uncompressed_data (NULL)
+    , _update_mark (0)
+    , _update_time (0)
+    , next (NULL)
+{
+    AVCodecContext* ctx = NULL;
+    AVCodec* codec;
+    AVFrame* frame = NULL;
+
+    enum CodecID type;
+
+    memset(_frames, 0, sizeof(_frames));
+    region_init(&_clip_region);
+    switch (codec_type) {
+    case RED_VIDEO_CODEC_TYPE_MJPEG:
+        type = CODEC_ID_MJPEG;
+        break;
+    default:
+        THROW("invalid vide codec type %u", codec_type);
+    }
+
+    if (!(codec = avcodec_find_decoder(type))) {
+        THROW("can't find codec %u", type);
+    }
+
+    if (!(ctx = avcodec_alloc_context())) {
+        THROW("alloc codec ctx failed");
+    }
+    try {
+        if (!(frame = avcodec_alloc_frame())) {
+            THROW("alloc frame failed");
+        }
+
+#ifdef WIN32
+        if (!create_bitmap(&_dc, &_prev_bitmap, &_uncompressed_data, &_stride,
+                           stream_width, stream_height)) {
+            THROW("create_bitmap failed");
+        }
+#else
+        _uncompressed_data = new uint8_t[_stride * stream_height];
+#endif
+        _pixmap.width = src_width;
+        _pixmap.height = src_height;
+
+        if (top_down) {
+            _pixmap.data = _uncompressed_data;
+            _pixmap.stride = _stride;
+        } else {
+#ifdef WIN32
+            SetViewportOrgEx(_dc, 0, stream_height - src_height, NULL);
+#endif
+            _pixmap.data = _uncompressed_data + _stride * (src_height - 1);
+            _pixmap.stride = -_stride;
+        }
+
+        set_clip(clip_type, num_clip_rects, clip_rects);
+
+        Lock lock(avcodec_mutex);
+        if (avcodec_open(ctx, codec) < 0) {
+            THROW("open avcodec failed");
+        }
+    } catch (...) {
+        av_free(frame);
+        av_free(ctx);
+        release_all_bufs();
+        throw;
+    }
+    _frame = frame;
+    _ctx = ctx;
+}
+
+VideoStream::~VideoStream()
+{
+    if (_ctx) {
+        Lock lock(avcodec_mutex);
+        avcodec_close(_ctx);
+        av_free(_ctx);
+        av_free(_frame);
+    }
+    release_all_bufs();
+    region_destroy(&_clip_region);
+}
+
+void VideoStream::release_all_bufs()
+{
+    for (int i = 0; i < MAX_VIDEO_FRAMES; i++) {
+        delete[] _frames[i].compressed_data;
+    }
+#ifdef WIN32
+    if (_dc) {
+        HBITMAP bitmap = (HBITMAP)SelectObject(_dc, _prev_bitmap);
+        DeleteObject(bitmap);
+        DeleteObject(_dc);
+    }
+#else
+    delete[] _uncompressed_data;
+#endif
+}
+
+void VideoStream::free_frame(uint32_t frame_index)
+{
+    int slot = frame_slot(frame_index);
+    delete[] _frames[slot].compressed_data;
+    _frames[slot].compressed_data = NULL;
+}
+
+void VideoStream::remove_dead_frames(uint32_t mm_time)
+{
+    while (_frames_head != _frames_tail) {
+        if (int(_frames[frame_slot(_frames_tail)].mm_time - mm_time) >= MAX_UNDER) {
+            return;
+        }
+        free_frame(_frames_tail);
+        _frames_tail++;
+    }
+}
+
+void VideoStream::drop_one_frame()
+{
+    ASSERT(MAX_VIDEO_FRAMES > 2 && (_frames_head - _frames_tail) == MAX_VIDEO_FRAMES);
+    int frame_index = _frames_head - _kill_mark++ % (MAX_VIDEO_FRAMES - 2) - 2;
+
+    free_frame(frame_index);
+
+    while (frame_index != _frames_tail) {
+        --frame_index;
+        _frames[frame_slot(frame_index + 1)] = _frames[frame_slot(frame_index)];
+    }
+    _frames_tail++;
+}
+
+bool VideoStream::is_time_to_display(uint32_t now, uint32_t frame_time)
+{
+    int delta = frame_time - now;
+    return delta <= MAX_OVER && delta >= MAX_UNDER;
+}
+
+void VideoStream::maintenance()
+{
+    uint32_t mm_time = _client.get_mm_time();
+
+    remove_dead_frames(mm_time);
+    if (!_update_mark && !_update_time && _frames_head != _frames_tail) {
+        VideoFrame* tail = &_frames[frame_slot(_frames_tail)];
+
+        ASSERT(tail->compressed_data);
+        uint8_t* data = tail->compressed_data;
+        uint32_t length = tail->compressed_data_size;
+        int got_picture = 0;
+        while (length > 0) {
+            int n = avcodec_decode_video(_ctx, _frame, &got_picture, data, length);
+            if (n < 0) {
+                THROW("decoding eror");
+            }
+            if (got_picture) {
+                yuv420_to_rgb(_frame, _uncompressed_data, _stream_width, _stream_height, _stride,
+                              _top_down);
+                ASSERT(length - n == 0);
+                break;
+            }
+            length -= n;
+            data += n;
+        }
+        if (got_picture) {
+#ifdef WIN32
+            _canvas.put_image(_dc, _pixmap, _dest, _clip);
+#else
+            _canvas.put_image(_pixmap, _dest, _clip);
+#endif
+            if (is_time_to_display(mm_time, tail->mm_time)) {
+                _update_mark = _channel.invalidate(_dest, true);
+                Platform::yield();
+            } else {
+                _update_time = tail->mm_time;
+                _channel.stream_update_request(_update_time);
+            }
+        }
+        free_frame(_frames_tail++);
+    }
+}
+
+uint32_t VideoStream::handle_timer_update(uint32_t now)
+{
+    if (!_update_time) {
+        return 0;
+    }
+
+    if (is_time_to_display(now, _update_time)) {
+        _update_time = 0;
+        _update_mark = _channel.invalidate(_dest, true);
+    } else if ((int)(_update_time - now) < 0) {
+        DBG(0, "to late");
+        _update_time = 0;
+    }
+    return _update_time;
+}
+
+void VideoStream::handle_update_mark(uint64_t update_mark)
+{
+    if (!_update_mark || update_mark < _update_mark) {
+        return;
+    }
+    _update_mark = 0;
+    maintenance();
+}
+
+uint32_t VideoStream::alloc_frame_slot()
+{
+    if ((_frames_head - _frames_tail) == MAX_VIDEO_FRAMES) {
+        drop_one_frame();
+    }
+    return frame_slot(_frames_head++);
+}
+
+void VideoStream::push_data(uint32_t mm_time, uint32_t length, uint8_t* data, uint32_t ped_size)
+{
+    if (ped_size < FF_INPUT_BUFFER_PADDING_SIZE) {
+        THROW("insufficieant pedding");
+    }
+    maintenance();
+    uint32_t frame_slot = alloc_frame_slot();
+    _frames[frame_slot].compressed_data = new uint8_t[length];
+    memcpy(_frames[frame_slot].compressed_data, data, length);
+    _frames[frame_slot].compressed_data_size = length;
+    _frames[frame_slot].mm_time = mm_time ? mm_time : 1;
+    maintenance();
+}
+
+void VideoStream::set_clip(int type, uint32_t num_clip_rects, Rect* clip_rects)
+{
+    if (type == CLIP_TYPE_NONE) {
+        _clip = NULL;
+        return;
+    }
+
+    ASSERT(type == CLIP_TYPE_RECTS)
+    region_clear(&_clip_region);
+
+    for (unsigned int i = 0; i < num_clip_rects; i++) {
+        region_add(&_clip_region, &clip_rects[i]);
+    }
+    _clip = &_clip_region;
+}
+
+void VideoStream::init()
+{
+    avcodec_init();
+    avcodec_register_all();
+    init_clip_array();
+}
+
+class AutoVStreamInit {
+public:
+    AutoVStreamInit()
+    {
+        VideoStream::init();
+    }
+};
+
+static AutoVStreamInit auto_init;
+
+
+StreamsTrigger::StreamsTrigger(DisplayChannel& channel)
+    : _channel (channel)
+{
+}
+
+void StreamsTrigger::on_event()
+{
+    _channel.on_streams_trigger();
+}
+
+#ifdef USE_OGL
+
+GLInterruptRecreate::GLInterruptRecreate(DisplayChannel& channel)
+    : _channel (channel)
+{
+}
+
+void GLInterruptRecreate::trigger()
+{
+    Lock lock(_lock);
+    EventsLoop::Trigger::trigger();
+    _cond.wait(lock);
+}
+
+void GLInterruptRecreate::on_event()
+{
+    Lock lock(_lock);
+    _channel.recreate_ogl_context_interrupt();
+    _cond.notify_one();
+}
+
+#endif
+
+void InterruptUpdate::on_event()
+{
+    _channel.update_interrupt();
+}
+
+InterruptUpdate::InterruptUpdate(DisplayChannel& channel)
+    : _channel (channel)
+{
+}
+
+class DisplayHandler: public MessageHandlerImp<DisplayChannel, RED_DISPLAY_MESSAGES_END> {
+public:
+    DisplayHandler(DisplayChannel& channel)
+        : MessageHandlerImp<DisplayChannel, RED_DISPLAY_MESSAGES_END>(channel) {}
+};
+
+DisplayChannel::DisplayChannel(RedClient& client, uint32_t id,
+                               PixmapCache& pixmap_cache, GlzDecoderWindow& glz_window)
+    : RedChannel(client, RED_CHANNEL_DISPLAY, id, new DisplayHandler(*this),
+                 Platform::PRIORITY_LOW)
+    , ScreenLayer (SCREEN_LAYER_DISPLAY, true)
+    , _canvas (NULL)
+    , _pixmap_cache (pixmap_cache)
+    , _glz_window (glz_window)
+    , _mark (false)
+    , _update_mark (0)
+    , _streams_timer (INVALID_TIMER)
+    , _next_timer_time (0)
+    , _active_streams (NULL)
+    , _streams_trigger (*this)
+#ifdef USE_OGL
+    , _gl_interrupt_recreate (*this)
+#endif
+    , _interrupt_update (*this)
+{
+    DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
+
+    handler->set_handler(RED_MIGRATE, &DisplayChannel::handle_migrate, 0);
+    handler->set_handler(RED_SET_ACK, &DisplayChannel::handle_set_ack, sizeof(RedSetAck));
+    handler->set_handler(RED_PING, &DisplayChannel::handle_ping, sizeof(RedPing));
+    handler->set_handler(RED_WAIT_FOR_CHANNELS, &DisplayChannel::handle_wait_for_channels,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISCONNECTING, &DisplayChannel::handle_disconnect,
+                         sizeof(RedDisconnect));
+    handler->set_handler(RED_NOTIFY, &DisplayChannel::handle_notify, sizeof(RedNotify));
+
+    handler->set_handler(RED_DISPLAY_MODE, &DisplayChannel::handle_mode, sizeof(RedMode));
+    handler->set_handler(RED_DISPLAY_MARK, &DisplayChannel::handle_mark, 0);
+    handler->set_handler(RED_DISPLAY_RESET, &DisplayChannel::handle_reset, 0);
+
+    handler->set_handler(RED_DISPLAY_INVAL_LIST,
+                         &DisplayChannel::handle_inval_list,
+                         sizeof(RedResorceList));
+    handler->set_handler(RED_DISPLAY_INVAL_ALL_PIXMAPS,
+                         &DisplayChannel::handle_inval_all_pixmaps,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISPLAY_INVAL_PALETTE,
+                         &DisplayChannel::handle_inval_palette, sizeof(RedInvalOne));
+    handler->set_handler(RED_DISPLAY_INVAL_ALL_PALETTES,
+                         &DisplayChannel::handle_inval_all_palettes, 0);
+
+    handler->set_handler(RED_DISPLAY_STREAM_CREATE, &DisplayChannel::handle_stream_create,
+                         sizeof(RedStreamCreate));
+    handler->set_handler(RED_DISPLAY_STREAM_CLIP, &DisplayChannel::handle_stream_clip,
+                         sizeof(RedStreamClip));
+    handler->set_handler(RED_DISPLAY_STREAM_DESTROY, &DisplayChannel::handle_stream_destroy,
+                         sizeof(RedStreamDestroy));
+    handler->set_handler(RED_DISPLAY_STREAM_DESTROY_ALL,
+                         &DisplayChannel::handle_stream_destroy_all, 0);
+
+    get_events_loop().add_trigger(_streams_trigger);
+#ifdef USE_OGL
+    get_events_loop().add_trigger(_gl_interrupt_recreate);
+#endif
+    get_events_loop().add_trigger(_interrupt_update);
+}
+
+DisplayChannel::~DisplayChannel()
+{
+    if (screen()) {
+        screen()->set_update_interrupt_trigger(NULL);
+    }
+    destroy_strams();
+}
+
+void DisplayChannel::destroy_strams()
+{
+    Lock lock(_streams_lock);
+    for (unsigned int i = 0; i < _streams.size(); i++) {
+        delete _streams[i];
+        _streams[i] = NULL;
+    }
+    _active_streams = NULL;
+}
+
+void DisplayChannel::set_draw_handlers()
+{
+    DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
+
+    handler->set_handler(RED_DISPLAY_COPY_BITS, &DisplayChannel::handle_copy_bits,
+                         sizeof(RedCopyBits));
+
+    handler->set_handler(RED_DISPLAY_DRAW_FILL, &DisplayChannel::handle_draw_fill,
+                         sizeof(RedFill));
+    handler->set_handler(RED_DISPLAY_DRAW_OPAQUE, &DisplayChannel::handle_draw_opaque,
+                         sizeof(RedOpaque));
+    handler->set_handler(RED_DISPLAY_DRAW_COPY, &DisplayChannel::handle_draw_copy,
+                         sizeof(RedCopy));
+    handler->set_handler(RED_DISPLAY_DRAW_BLEND, &DisplayChannel::handle_draw_blend,
+                         sizeof(RedBlend));
+    handler->set_handler(RED_DISPLAY_DRAW_BLACKNESS, &DisplayChannel::handle_draw_blackness,
+                         sizeof(RedBlackness));
+    handler->set_handler(RED_DISPLAY_DRAW_WHITENESS, &DisplayChannel::handle_draw_whiteness,
+                         sizeof(RedWhiteness));
+    handler->set_handler(RED_DISPLAY_DRAW_INVERS, &DisplayChannel::handle_draw_invers,
+                         sizeof(RedInvers));
+    handler->set_handler(RED_DISPLAY_DRAW_ROP3, &DisplayChannel::handle_draw_rop3,
+                         sizeof(RedRop3));
+    handler->set_handler(RED_DISPLAY_DRAW_STROKE, &DisplayChannel::handle_draw_stroke,
+                         sizeof(RedStroke));
+    handler->set_handler(RED_DISPLAY_DRAW_TEXT, &DisplayChannel::handle_draw_text,
+                         sizeof(RedText));
+    handler->set_handler(RED_DISPLAY_DRAW_TRANSPARENT,
+                         &DisplayChannel::handle_draw_transparent, sizeof(RedTransparent));
+    handler->set_handler(RED_DISPLAY_DRAW_ALPHA_BLEND,
+                         &DisplayChannel::handle_draw_alpha_blend, sizeof(RedAlphaBlend));
+    handler->set_handler(RED_DISPLAY_STREAM_DATA, &DisplayChannel::handle_stream_data,
+                         sizeof(RedStreamData));
+}
+
+void DisplayChannel::clear_draw_handlers()
+{
+    DisplayHandler* handler = static_cast<DisplayHandler*>(get_message_handler());
+
+    handler->set_handler(RED_DISPLAY_COPY_BITS, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_FILL, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_OPAQUE, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_COPY, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_BLEND, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_BLACKNESS, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_WHITENESS, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_INVERS, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_ROP3, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_STROKE, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_TEXT, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_TRANSPARENT, NULL, 0);
+    handler->set_handler(RED_DISPLAY_DRAW_ALPHA_BLEND, NULL, 0);
+    handler->set_handler(RED_DISPLAY_STREAM_DATA, NULL, 0);
+}
+
+void DisplayChannel::copy_pixels(const QRegion& dest_region,
+                                 const PixmapHeader &dest_pixmap)
+{
+    if (!_canvas.get()) {
+        return;
+    }
+
+    _canvas->copy_pixels(dest_region, NULL, &dest_pixmap);
+}
+
+#ifdef USE_OGL
+void DisplayChannel::recreate_ogl_context_interrupt()
+{
+    Canvas* canvas = _canvas.release();
+    if (canvas) {
+        ((GCanvas *)canvas)->textures_lost();
+        delete canvas;
+    }
+
+    if (!create_ogl_canvas(_x_res, _y_res, _depth, 0, _rendertype)) {
+        THROW("create_ogl_canvas failed");
+    }
+}
+
+void DisplayChannel::recreate_ogl_context()
+{
+    if (_canvas.get() && _canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+        if (!screen()->need_recreate_context_gl()) {
+            _gl_interrupt_recreate.trigger();
+        }
+    }
+}
+
+#endif
+
+void DisplayChannel::update_interrupt()
+{
+    if (!_canvas.get() || !screen()) {
+        return;
+    }
+
+#ifdef USE_OGL
+    if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+        ((GCanvas *)(_canvas.get()))->pre_gl_copy();
+    }
+#endif
+
+    screen()->update();
+
+#ifdef USE_OGL
+    if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+        ((GCanvas *)(_canvas.get()))->post_gl_copy();
+    }
+#endif
+}
+
+#ifdef USE_OGL
+
+void DisplayChannel::pre_migrate()
+{
+}
+
+void DisplayChannel::post_migrate()
+{
+#ifdef USE_OGL
+    if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+        _gl_interrupt_recreate.trigger();
+    }
+#endif
+}
+
+#endif
+
+void DisplayChannel::copy_pixels(const QRegion& dest_region,
+                                 RedDrawable& dest_dc)
+{
+    if (!_canvas.get()) {
+        return;
+    }
+
+    _canvas->copy_pixels(dest_region, dest_dc);
+}
+
+class CreateTimerEvent: public SyncEvent {
+public:
+    CreateTimerEvent(timer_proc_t proc, void* user_data)
+        : SyncEvent()
+        , _proc (proc)
+        , _user_data (user_data)
+        , _timer (INVALID_TIMER)
+    {
+    }
+
+    virtual ~CreateTimerEvent()
+    {
+        ASSERT(_timer == INVALID_TIMER);
+    }
+
+    virtual void do_responce(Application& application)
+    {
+        if ((_timer = Platform::create_interval_timer(_proc, _user_data)) == INVALID_TIMER) {
+            THROW("create timer failed");
+        }
+    }
+
+    TimerID release() { TimerID ret = _timer; _timer = INVALID_TIMER; return ret;}
+
+private:
+    timer_proc_t _proc;
+    void* _user_data;
+    TimerID _timer;
+};
+
+class DestroyTimerEvent: public Event {
+public:
+    DestroyTimerEvent(TimerID timer) : _timer (timer) {}
+
+    virtual void responce(Application& application)
+    {
+        Platform::destroy_interval_timer(_timer);
+    }
+
+private:
+    TimerID _timer;
+};
+
+class ActivateTimerEvent: public Event {
+public:
+    ActivateTimerEvent(DisplayChannel& channel)
+        : _channel (channel)
+    {
+    }
+
+    virtual void responce(Application& application)
+    {
+        _channel.activate_streams_timer();
+    }
+
+private:
+    DisplayChannel& _channel;
+};
+
+void DisplayChannel::streams_timer_callback(void* opaque, TimerID timer)
+{
+    ((DisplayChannel *)opaque)->streams_time();
+}
+
+#define RESET_TIMEOUT (1000 * 5)
+
+void DisplayChannel::reset_timer_callback(void* opaque, TimerID timer)
+{
+    ((RedScreen *)opaque)->unref();
+    Platform::destroy_interval_timer(timer);
+}
+
+void DisplayChannel::on_connect()
+{
+    Message* message = new Message(REDC_DISPLAY_INIT, sizeof(RedcDisplayInit));
+    RedcDisplayInit* init = (RedcDisplayInit*)message->data();
+    init->pixmap_cache_id = 1;
+    init->pixmap_cache_size = get_client().get_pixmap_cache_size();
+    init->glz_dictionary_id = 1;
+    init->glz_dictionary_window_size = get_client().get_glz_window_size();
+    post_message(message);
+    AutoRef<CreateTimerEvent> event(new CreateTimerEvent(streams_timer_callback, this));
+    get_client().push_event(*event);
+    (*event)->wait();
+    _streams_timer = (*event)->release();
+    if (!(*event)->success()) {
+        THROW("create timer failed");
+    }
+}
+
+void DisplayChannel::on_disconnect()
+{
+    if (_canvas.get()) {
+        _canvas->clear();
+    }
+
+    if (screen()) {
+        screen()->set_update_interrupt_trigger(NULL);
+    }
+    detach_from_screen(get_client().get_application());
+    AutoRef<DestroyTimerEvent> event(new DestroyTimerEvent(_streams_timer));
+    get_client().push_event(*event);
+    AutoRef<SyncEvent> sync_event(new SyncEvent());
+    get_client().push_event(*sync_event);
+    (*sync_event)->wait();
+}
+
+bool DisplayChannel::create_cairo_canvas(int width, int height, int depth)
+{
+    try {
+        std::auto_ptr<CCanvas> canvas(new CCanvas(_pixmap_cache, _palette_cache, _glz_window));
+        canvas->set_mode(width, height, depth, screen()->get_window());
+        _canvas.reset(canvas.release());
+        LOG_INFO("display %d: using cairo", get_id());
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+#ifdef USE_OGL
+bool DisplayChannel::create_ogl_canvas(int width, int height, int depth,
+                                       bool recreate, RenderType rendertype)
+{
+    try {
+        RedWindow *win;
+        int ret = 1;
+
+        std::auto_ptr<GCanvas> canvas(new GCanvas(_pixmap_cache,
+                                                  _palette_cache,
+                                                  _glz_window));
+
+        win = screen()->get_window();
+        if (!ret) {
+            return false;
+        }
+
+        screen()->untouch_context();
+
+        canvas->set_mode(width, height, depth, win, rendertype);
+
+        _canvas.reset(canvas.release());
+        _rendertype = rendertype;
+        LOG_INFO("display %d: using ogl", get_id());
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+#endif
+
+#ifdef WIN32
+bool DisplayChannel::create_gdi_canvas(int width, int height, int depth)
+{
+    try {
+        std::auto_ptr<GDICanvas> canvas(
+            new GDICanvas(_pixmap_cache, _palette_cache, _glz_window));
+        canvas->set_mode(width, height, depth);
+        _canvas.reset(canvas.release());
+        LOG_INFO("display %d: using gdi", get_id());
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+#endif
+
+void DisplayChannel::destroy_canvas()
+{
+    Canvas* canvas = _canvas.release();
+
+    if (canvas) {
+        delete canvas;
+    }
+}
+
+void DisplayChannel::create_canvas(const std::vector<int>& canvas_types, int width,
+                                   int height, int depth)
+{
+#ifdef USE_OGL
+    bool recreate = true;
+#endif
+    unsigned int i;
+
+    clear_draw_handlers();
+
+#ifdef USE_OGL
+    if (screen()->need_recreate_context_gl()) {
+        recreate = false;
+    }
+#endif
+
+    screen()->set_update_interrupt_trigger(NULL);
+
+    for (i = 0; i < canvas_types.size(); i++) {
+
+        if (canvas_types[i] == CANVAS_OPTION_CAIRO && create_cairo_canvas(width, height, depth)) {
+            break;
+        }
+#ifdef USE_OGL
+        if (canvas_types[i] == CANVAS_OPTION_OGL_FBO && create_ogl_canvas(width, height, depth,
+                                                                          recreate,
+                                                                          RENDER_TYPE_FBO)) {
+            break;
+        }
+        if (canvas_types[i] == CANVAS_OPTION_OGL_PBUFF && create_ogl_canvas(width, height, depth,
+                                                                            recreate,
+                                                                            RENDER_TYPE_PBUFF)) {
+            break;
+        }
+#endif
+#ifdef WIN32
+        if (canvas_types[i] == CANVAS_OPTION_GDI && create_gdi_canvas(width, height, depth)) {
+            break;
+        }
+#endif
+    }
+
+    if (i == canvas_types.size()) {
+        THROW("create canvas failed");
+    }
+
+    set_draw_handlers();
+}
+
+void DisplayChannel::handle_mode(RedPeer::InMessage* message)
+{
+    RedMode *mode = (RedMode *)message->data();
+
+    _mark = false;
+    attach_to_screen(get_client().get_application(), get_id());
+    clear_area();
+#ifdef USE_OGL
+    if (screen()) {
+        if (_canvas.get()) {
+            if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+                screen()->unset_type_gl();
+                //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+            }
+        }
+    }
+#endif
+    destroy_canvas();
+    AutoRef<SetModeEvent> event(new SetModeEvent(*this, mode->x_res,
+                                                 mode->y_res, mode->bits));
+    get_client().push_event(*event);
+    (*event)->wait();
+    if (!(*event)->success()) {
+        THROW("set mode failed");
+    }
+
+    _x_res = mode->x_res;
+    _y_res = mode->y_res;
+    _depth = mode->bits;
+
+    create_canvas(get_client().get_application().get_canvas_types(), _x_res,
+                  _y_res, _depth);
+#ifdef USE_OGL
+    if (_canvas->get_pixmap_type() == CANVAS_TYPE_GL) {
+        screen()->set_update_interrupt_trigger(&_interrupt_update);
+        screen()->set_type_gl();
+    }
+#endif
+}
+
+void DisplayChannel::handle_mark(RedPeer::InMessage *message)
+{
+    _mark = true;
+    Rect area;
+    area.top = area.left = 0;
+    area.right = _x_res;
+    area.bottom = _y_res;
+
+    AutoRef<DisplayMarkEvent> event(new DisplayMarkEvent(get_id()));
+    get_client().push_event(*event);
+    set_rect_area(area);
+}
+
+void DisplayChannel::handle_reset(RedPeer::InMessage *message)
+{
+    TimerID reset_timer;
+
+    screen()->set_update_interrupt_trigger(NULL);
+
+    if (_canvas.get()) {
+        _canvas->clear();
+    }
+    reset_timer = Platform::create_interval_timer(reset_timer_callback, screen()->ref());
+    if (reset_timer == INVALID_TIMER) {
+        THROW("invalid reset timer");
+    }
+    detach_from_screen(get_client().get_application());
+    _palette_cache.clear();
+
+    Platform::activate_interval_timer(reset_timer, RESET_TIMEOUT);
+}
+
+void DisplayChannel::handle_inval_list(RedPeer::InMessage* message)
+{
+    RedResorceList *inval_list = (RedResorceList *)message->data();
+
+    if (message->size() <
+                        sizeof(*inval_list) + inval_list->count * sizeof(inval_list->resorces[0])) {
+        THROW("access violation");
+    }
+
+    for (int i = 0; i < inval_list->count; i++) {
+        if (inval_list->resorces[i].type != RED_RES_TYPE_PIXMAP) {
+            THROW("invalid res type");
+        }
+
+        _pixmap_cache.remove(inval_list->resorces[i].id);
+    }
+}
+
+void DisplayChannel::handle_inval_all_pixmaps(RedPeer::InMessage* message)
+{
+    RedWaitForChannels *wait = (RedWaitForChannels *)message->data();
+    if (message->size() < sizeof(*wait) + wait->wait_count * sizeof(wait->wait_list[0])) {
+        THROW("access violation");
+    }
+    get_client().wait_for_channels(wait->wait_count, wait->wait_list);
+    _pixmap_cache.clear();
+}
+
+void DisplayChannel::handle_inval_palette(RedPeer::InMessage* message)
+{
+    RedInvalOne* inval = (RedInvalOne*)message->data();
+    _palette_cache.remove(inval->id);
+}
+
+void DisplayChannel::handle_inval_all_palettes(RedPeer::InMessage* message)
+{
+    _palette_cache.clear();
+}
+
+void DisplayChannel::set_clip_rects(const Clip& clip, uint32_t& num_clip_rects,
+                                    Rect*& clip_rects, unsigned long addr_offset,
+                                    uint8_t *min, uint8_t *max)
+{
+    switch (clip.type) {
+    case CLIP_TYPE_RECTS: {
+        uint32_t* n = (uint32_t*)GET_ADDRESS(clip.data + addr_offset);
+        if (n < (uint32_t*)min || n + 1 > (uint32_t*)max) {
+            THROW("access violation");
+        }
+        num_clip_rects = *n;
+        clip_rects = (Rect *)(n + 1);
+        if (clip_rects + num_clip_rects > (Rect*)max) {
+            THROW("access violation");
+        }
+        break;
+    }
+    case CLIP_TYPE_NONE:
+        num_clip_rects = 0;
+        clip_rects = NULL;
+        break;
+    case CLIP_TYPE_PATH:
+        THROW("unexpected clip type");
+    }
+}
+
+void DisplayChannel::handle_stream_create(RedPeer::InMessage* message)
+{
+    RedStreamCreate* stream_create = (RedStreamCreate*)message->data();
+
+    Lock lock(_streams_lock);
+    if (_streams.size() <= stream_create->id) {
+        _streams.resize(stream_create->id + 1);
+    }
+
+    if (_streams[stream_create->id]) {
+        THROW("stream exist");
+    }
+
+    uint32_t num_clip_rects;
+    Rect* clip_rects;
+    set_clip_rects(stream_create->clip, num_clip_rects, clip_rects,
+                   (unsigned long)message->data(), (uint8_t*)(stream_create + 1),
+                   message->data() + message->size());
+    _streams[stream_create->id] = new VideoStream(get_client(), *_canvas.get(),
+                                                  *this, stream_create->codec_type,
+                                                  !!(stream_create->flags & STREAM_TOP_DOWN),
+                                                  stream_create->stream_width,
+                                                  stream_create->stream_height,
+                                                  stream_create->src_width,
+                                                  stream_create->src_height,
+                                                  &stream_create->dest,
+                                                  stream_create->clip.type,
+                                                  num_clip_rects,
+                                                  clip_rects);
+    _streams[stream_create->id]->next = _active_streams;
+    _active_streams = _streams[stream_create->id];
+}
+
+void DisplayChannel::handle_stream_data(RedPeer::InMessage* message)
+{
+    RedStreamData* stream_data = (RedStreamData*)message->data();
+    VideoStream* stream;
+
+    if (stream_data->id >= _streams.size() || !(stream = _streams[stream_data->id])) {
+        THROW("invalid stream");
+    }
+
+    if (message->size() < sizeof(RedStreamData) + stream_data->data_size + stream_data->ped_size) {
+        THROW("access violation");
+    }
+
+    stream->push_data(stream_data->multi_media_time, stream_data->data_size, stream_data->data,
+                      stream_data->ped_size);
+}
+
+void DisplayChannel::handle_stream_clip(RedPeer::InMessage* message)
+{
+    RedStreamClip* clip_data = (RedStreamClip*)message->data();
+    VideoStream* stream;
+    uint32_t num_clip_rects;
+    Rect* clip_rects;
+
+    if (clip_data->id >= _streams.size() || !(stream = _streams[clip_data->id])) {
+        THROW("invalid stream");
+    }
+
+    if (message->size() < sizeof(RedStreamClip)) {
+        THROW("access violation");
+    }
+    set_clip_rects(clip_data->clip, num_clip_rects, clip_rects,
+                   (unsigned long)message->data(), (uint8_t*)(clip_data + 1),
+                   message->data() + message->size());
+    Lock lock(_streams_lock);
+    stream->set_clip(clip_data->clip.type, num_clip_rects, clip_rects);
+}
+
+void DisplayChannel::handle_stream_destroy(RedPeer::InMessage* message)
+{
+    RedStreamDestroy* stream_destroy = (RedStreamDestroy*)message->data();
+
+    if (stream_destroy->id >= _streams.size() || !_streams[stream_destroy->id]) {
+        THROW("invalid stream");
+    }
+    Lock lock(_streams_lock);
+
+    VideoStream **active_stream = &_active_streams;
+    for (;;) {
+        if (!*active_stream) {
+            THROW("not in actibe streams");
+        }
+
+        if (*active_stream == _streams[stream_destroy->id]) {
+            *active_stream = _streams[stream_destroy->id]->next;
+            break;
+        }
+        active_stream = &(*active_stream)->next;
+    }
+
+    delete _streams[stream_destroy->id];
+    _streams[stream_destroy->id] = NULL;
+}
+
+void DisplayChannel::handle_stream_destroy_all(RedPeer::InMessage* message)
+{
+    destroy_strams();
+}
+
+#define PRE_DRAW
+#define POST_DRAW
+
+#define DRAW(type) {                                \
+    PRE_DRAW;                                       \
+    _canvas->draw_##type(*type, message->size());   \
+    POST_DRAW;                                      \
+    invalidate(type->base.box, false);              \
+}
+
+void DisplayChannel::handle_copy_bits(RedPeer::InMessage* message)
+{
+    RedCopyBits* copy_bits = (RedCopyBits*)message->data();
+    PRE_DRAW;
+    _canvas->copy_bits(*copy_bits, message->size());
+    POST_DRAW;
+    invalidate(copy_bits->base.box, false);
+}
+
+void DisplayChannel::handle_draw_fill(RedPeer::InMessage* message)
+{
+    RedFill* fill = (RedFill*)message->data();
+    DRAW(fill);
+}
+
+void DisplayChannel::handle_draw_opaque(RedPeer::InMessage* message)
+{
+    RedOpaque* opaque = (RedOpaque*)message->data();
+    DRAW(opaque);
+}
+
+void DisplayChannel::handle_draw_copy(RedPeer::InMessage* message)
+{
+    RedCopy* copy = (RedCopy*)message->data();
+    DRAW(copy);
+}
+
+void DisplayChannel::handle_draw_blend(RedPeer::InMessage* message)
+{
+    RedBlend* blend = (RedBlend*)message->data();
+    DRAW(blend);
+}
+
+void DisplayChannel::handle_draw_blackness(RedPeer::InMessage* message)
+{
+    RedBlackness* blackness = (RedBlackness*)message->data();
+    DRAW(blackness);
+}
+
+void DisplayChannel::handle_draw_whiteness(RedPeer::InMessage* message)
+{
+    RedWhiteness* whiteness = (RedWhiteness*)message->data();
+    DRAW(whiteness);
+}
+
+void DisplayChannel::handle_draw_invers(RedPeer::InMessage* message)
+{
+    RedInvers* invers = (RedInvers*)message->data();
+    DRAW(invers);
+}
+
+void DisplayChannel::handle_draw_rop3(RedPeer::InMessage* message)
+{
+    RedRop3* rop3 = (RedRop3*)message->data();
+    DRAW(rop3);
+}
+
+void DisplayChannel::handle_draw_stroke(RedPeer::InMessage* message)
+{
+    RedStroke* stroke = (RedStroke*)message->data();
+    DRAW(stroke);
+}
+
+void DisplayChannel::handle_draw_text(RedPeer::InMessage* message)
+{
+    RedText* text = (RedText*)message->data();
+    DRAW(text);
+}
+
+void DisplayChannel::handle_draw_transparent(RedPeer::InMessage* message)
+{
+    RedTransparent* transparent = (RedTransparent*)message->data();
+    DRAW(transparent);
+}
+
+void DisplayChannel::handle_draw_alpha_blend(RedPeer::InMessage* message)
+{
+    RedAlphaBlend* alpha_blend = (RedAlphaBlend*)message->data();
+    DRAW(alpha_blend);
+}
+
+void DisplayChannel::streams_time()
+{
+    _next_timer_time = 0;
+    Lock lock(_streams_lock);
+    uint32_t mm_time = get_client().get_mm_time();
+    uint32_t next_time = 0;
+    VideoStream* stream = _active_streams;
+    while (stream) {
+        uint32_t next_frame_time;
+        if ((next_frame_time = stream->handle_timer_update(mm_time))) {
+            if (!next_time || int(next_frame_time - next_time) < 0) {
+                next_time = next_frame_time;
+            }
+        }
+        stream = stream->next;
+    }
+    Lock timer_lock(_timer_lock);
+    mm_time = get_client().get_mm_time();
+    next_time = mm_time + 15;
+    if (next_time && (!_next_timer_time || int(next_time - _next_timer_time) < 0)) {
+        Platform::activate_interval_timer(_streams_timer, MAX(int(next_time - mm_time), 0));
+        _next_timer_time = next_time;
+    } else if (!_next_timer_time) {
+        Platform::deactivate_interval_timer(_streams_timer);
+    }
+    timer_lock.unlock();
+    lock.unlock();
+    Platform::yield();
+}
+
+void DisplayChannel::activate_streams_timer()
+{
+    uint32_t next_time = _next_timer_time;
+    if (!next_time) {
+        return;
+    }
+
+    int delta = next_time - get_client().get_mm_time();
+    if (delta <= 0) {
+        streams_time();
+    } else {
+        Lock timer_lock(_timer_lock);
+        if (!_next_timer_time) {
+            return;
+        }
+        delta = _next_timer_time - get_client().get_mm_time();
+        Platform::activate_interval_timer(_streams_timer, delta);
+    }
+}
+
+void DisplayChannel::stream_update_request(uint32_t mm_time)
+{
+    Lock lock(_timer_lock);
+    if (_next_timer_time && int(mm_time - _next_timer_time) > 0) {
+        return;
+    }
+    _next_timer_time = mm_time;
+    lock.unlock();
+    AutoRef<ActivateTimerEvent> event(new ActivateTimerEvent(*this));
+    get_client().push_event(*event);
+}
+
+void DisplayChannel::on_update_completion(uint64_t mark)
+{
+#ifndef RED64
+    Lock lock(_mark_lock);
+#endif
+    _update_mark = mark;
+#ifndef RED64
+    lock.unlock();
+#endif
+    _streams_trigger.trigger();
+}
+
+void DisplayChannel::on_streams_trigger()
+{
+#ifndef RED64
+    Lock lock(_mark_lock);
+#endif
+    uint64_t update_mark = _update_mark;
+#ifndef RED64
+    lock.unlock();
+#endif
+    VideoStream* stream = _active_streams;
+    while (stream) {
+        stream->handle_update_mark(update_mark);
+        stream = stream->next;
+    }
+}
+
+class DisplayFactory: public ChannelFactory {
+public:
+    DisplayFactory() : ChannelFactory(RED_CHANNEL_DISPLAY) {}
+    virtual RedChannel* construct(RedClient& client, uint32_t id)
+    {
+        return new DisplayChannel(client, id,
+                                  client.get_pixmap_cache(), client.get_glz_window());
+    }
+};
+
+static DisplayFactory factory;
+
+ChannelFactory& DisplayChannel::Factory()
+{
+    return factory;
+}
+
diff --git a/client/display_channel.h b/client/display_channel.h
new file mode 100644
index 00000000..894c604f
--- /dev/null
+++ b/client/display_channel.h
@@ -0,0 +1,190 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_DISPLAY_CHANNEL
+#define _H_DISPLAY_CHANNEL
+
+#include "common.h"
+#include "canvas.h"
+#include "region.h"
+#include "red_channel.h"
+#include "cairo.h"
+#include "cache.hpp"
+#include "screen_layer.h"
+#include "events_loop.h"
+#ifdef USE_OGL
+#include "red_pixmap_gl.h"
+#endif
+#include "glz_decoder_window.h"
+
+class RedScreen;
+class ChannelFactory;
+class VideoStream;
+class DisplayChannel;
+
+class StreamsTrigger: public EventsLoop::Trigger {
+public:
+    StreamsTrigger(DisplayChannel& channel);
+
+    virtual void on_event();
+
+private:
+    DisplayChannel& _channel;
+};
+
+#ifdef USE_OGL
+class GLInterruptRecreate: public EventsLoop::Trigger {
+public:
+    GLInterruptRecreate(DisplayChannel& channel);
+    virtual void trigger();
+    virtual void on_event();
+
+private:
+    DisplayChannel& _channel;
+    Mutex _lock;
+    Condition _cond;
+};
+#endif
+
+class InterruptUpdate: public EventsLoop::Trigger {
+public:
+    InterruptUpdate(DisplayChannel& channel);
+
+    virtual void on_event();
+
+private:
+    DisplayChannel& _channel;
+};
+
+
+class DisplayChannel: public RedChannel, public ScreenLayer {
+public:
+    DisplayChannel(RedClient& client, uint32_t id,
+                   PixmapCache& pixmap_cache, GlzDecoderWindow& glz_window);
+    virtual ~DisplayChannel();
+
+    virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc);
+    virtual void copy_pixels(const QRegion& dest_region, const PixmapHeader &dest);
+#ifdef USE_OGL
+    virtual void recreate_ogl_context();
+    virtual void recreate_ogl_context_interrupt();
+    virtual void pre_migrate();
+    virtual void post_migrate();
+#endif
+    virtual void update_interrupt();
+
+    static ChannelFactory& Factory();
+
+protected:
+    virtual void on_connect();
+    virtual void on_disconnect();
+
+private:
+    void set_draw_handlers();
+    void clear_draw_handlers();
+    bool create_cairo_canvas(int width, int height, int depth);
+#ifdef USE_OGL
+    bool create_ogl_canvas(int width, int height, int depth, bool recreate,
+                           RenderType rendertype);
+#endif
+#ifdef WIN32
+    bool create_gdi_canvas(int width, int height, int depth);
+#endif
+    void destroy_canvas();
+    void create_canvas(const std::vector<int>& canvas_type, int width, int height,
+                       int depth);
+    void destroy_strams();
+
+    void handle_mode(RedPeer::InMessage* message);
+    void handle_mark(RedPeer::InMessage* message);
+    void handle_reset(RedPeer::InMessage* message);
+
+    void handle_inval_list(RedPeer::InMessage* message);
+    void handle_inval_all_pixmaps(RedPeer::InMessage* message);
+    void handle_inval_palette(RedPeer::InMessage* message);
+    void handle_inval_all_palettes(RedPeer::InMessage* message);
+    void handle_copy_bits(RedPeer::InMessage* message);
+    void handle_stream_create(RedPeer::InMessage* message);
+    void handle_stream_data(RedPeer::InMessage* message);
+    void handle_stream_clip(RedPeer::InMessage* message);
+    void handle_stream_destroy(RedPeer::InMessage* message);
+    void handle_stream_destroy_all(RedPeer::InMessage* message);
+
+    void handle_draw_fill(RedPeer::InMessage* message);
+    void handle_draw_opaque(RedPeer::InMessage* message);
+    void handle_draw_copy(RedPeer::InMessage* message);
+    void handle_draw_blend(RedPeer::InMessage* message);
+    void handle_draw_blackness(RedPeer::InMessage* message);
+    void handle_draw_whiteness(RedPeer::InMessage* message);
+    void handle_draw_invers(RedPeer::InMessage* message);
+    void handle_draw_rop3(RedPeer::InMessage* message);
+    void handle_draw_stroke(RedPeer::InMessage* message);
+    void handle_draw_text(RedPeer::InMessage* message);
+    void handle_draw_transparent(RedPeer::InMessage* message);
+    void handle_draw_alpha_blend(RedPeer::InMessage* message);
+
+    void on_streams_trigger();
+    virtual void on_update_completion(uint64_t mark);
+    void streams_time();
+    void activate_streams_timer();
+    void stream_update_request(uint32_t update_time);
+
+    static void set_clip_rects(const Clip& clip, uint32_t& num_clip_rects, Rect*& clip_rects,
+                               unsigned long addr_offset, uint8_t *min, uint8_t *max);
+    static void streams_timer_callback(void* opaque, TimerID timer);
+    static void reset_timer_callback(void* opaque, TimerID timer);
+
+private:
+    std::auto_ptr<Canvas> _canvas;
+    PixmapCache& _pixmap_cache;
+    PaletteCache _palette_cache;
+    GlzDecoderWindow& _glz_window;
+    bool _mark;
+    int _x_res;
+    int _y_res;
+    int _depth;
+#ifdef USE_OGL
+    RenderType _rendertype;
+#endif
+
+#ifndef RED64
+    Mutex _mark_lock;
+#endif
+    uint64_t _update_mark;
+    Mutex _streams_lock;
+
+    Mutex _timer_lock;
+    TimerID _streams_timer;
+    uint32_t _next_timer_time;
+
+    std::vector<VideoStream*> _streams;
+    VideoStream* _active_streams;
+    StreamsTrigger _streams_trigger;
+#ifdef USE_OGL
+    GLInterruptRecreate _gl_interrupt_recreate;
+#endif
+    InterruptUpdate _interrupt_update;
+    friend class SetModeEvent;
+    friend class ActivateTimerEvent;
+    friend class VideoStream;
+    friend class StreamsTrigger;
+    friend class GLInterupt;
+    friend void streams_timer_callback(void* opaque, TimerID timer);
+};
+
+#endif
+
diff --git a/client/events_loop.h b/client/events_loop.h
new file mode 100644
index 00000000..50a83e1d
--- /dev/null
+++ b/client/events_loop.h
@@ -0,0 +1,86 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_EVENTS_LOOP
+#define _H_EVENTS_LOOP
+
+#include "common.h"
+#include "events_loop_p.h"
+
+class EventSource;
+
+class EventsLoop: public EventsLoop_p {
+public:
+    class Trigger;
+    class Socket;
+    class File;
+
+    EventsLoop();
+    virtual ~EventsLoop();
+
+    void add_trigger(Trigger& trigger);
+    void remove_trigger(Trigger& trigger);
+    void add_socket(Socket& socket);
+    void remove_socket(Socket& socket);
+    void add_file(File& file);
+    void remove_file(File& file);
+    void run();
+    // FIXME: temporary - need to adjust the loop for the main thread
+    void run_once(int timeout_milli = INFINITE);
+};
+
+class EventSource {
+public:
+    virtual ~EventSource() {}
+    virtual void on_event() = 0;
+
+private:
+    virtual void action() {on_event();}
+
+    friend class EventsLoop;
+};
+
+class EventsLoop::Trigger: public EventSource, private Trigger_p {
+public:
+    Trigger();
+    virtual ~Trigger();
+    virtual void trigger();
+    virtual void reset();
+
+private:
+    virtual void action();
+
+    friend class EventsLoop;
+};
+
+class EventsLoop::Socket: public EventSource {
+protected:
+    virtual int get_socket() = 0;
+
+    friend class EventsLoop;
+};
+
+
+class EventsLoop::File: public EventSource {
+protected:
+    virtual int get_fd() = 0;
+
+    friend class EventsLoop;
+};
+
+#endif
+
diff --git a/client/gdi_canvas.cpp b/client/gdi_canvas.cpp
new file mode 100644
index 00000000..f8aaaef8
--- /dev/null
+++ b/client/gdi_canvas.cpp
@@ -0,0 +1,24 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "utils.h"
+
+#define CANVAS_ERROR(format, ...) THROW(format, ## __VA_ARGS__)
+
+#include "../common/gdi_canvas.c"
+
diff --git a/client/gl_canvas.cpp b/client/gl_canvas.cpp
new file mode 100644
index 00000000..e66be864
--- /dev/null
+++ b/client/gl_canvas.cpp
@@ -0,0 +1,21 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+#include "common.h"
+#include "../common/gl_canvas.c"
+
diff --git a/client/glc.cpp b/client/glc.cpp
new file mode 100644
index 00000000..5a8e5990
--- /dev/null
+++ b/client/glc.cpp
@@ -0,0 +1,21 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+#include "common.h"
+#include "../common/glc.c"
+
diff --git a/client/glz_decode_tmpl.c b/client/glz_decode_tmpl.c
new file mode 100644
index 00000000..6942b73c
--- /dev/null
+++ b/client/glz_decode_tmpl.c
@@ -0,0 +1,335 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+// External defines: PLT, RGBX/PLTXX/ALPHA, TO_RGB32.
+// If PLT4/1 and TO_RGB32 are defined, we need CAST_PLT_DISTANCE (
+// because then the number of pixels differ from the units used in the compression)
+
+/*
+    For each output pixel type the following macros are defined:
+    OUT_PIXEL                      - the output pixel type
+    COPY_PIXEL(p, out)              - assignes the pixel to the place pointed by out and
+                                      increases out. Used in RLE.
+                                      Need special handling because in alpha we copy only
+                                      the pad byte.
+    COPY_REF_PIXEL(ref, out)      - copies the pixel pointed by ref to the pixel pointed by out.
+                                    Increases ref and out.
+    COPY_COMP_PIXEL(encoder, out) - copies pixel from the compressed buffer to the decompressed
+                                    buffer. Increases out.
+*/
+
+#if !defined(LZ_RGB_ALPHA)
+#define COPY_PIXEL(p, out) (*(out++) = p)
+#define COPY_REF_PIXEL(ref, out) (*(out++) = *(ref++))
+#endif
+
+// decompressing plt to plt
+#ifdef LZ_PLT
+#ifndef TO_RGB32
+#define OUT_PIXEL one_byte_pixel_t
+#define FNAME(name) glz_plt_##name
+#define COPY_COMP_PIXEL(in, out) {(out)->a = *(in++); out++;}
+#else // TO_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define COPY_PLT_ENTRY(ent, out) {\
+    (out)->b = ent; (out)->g = (ent >> 8); (out)->r = (ent >> 16); (out)->pad = 0;}
+#ifdef PLT8
+#define FNAME(name) glz_plt8_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette) {         \
+    uint32_t rgb = palette->ents[*(in++)];          \
+    COPY_PLT_ENTRY(rgb, out);                       \
+    out++;                                          \
+}
+#elif defined(PLT4_BE)
+#define FNAME(name) glz_plt4_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){                                    \
+    uint8_t byte = *(in++);                                                   \
+    uint32_t rgb = palette->ents[((byte >> 4) & 0x0f) % (palette->num_ents)]; \
+    COPY_PLT_ENTRY(rgb, out);                                                 \
+    out++;                                                                    \
+    rgb = palette->ents[(byte & 0x0f) % (palette->num_ents)];                 \
+    COPY_PLT_ENTRY(rgb, out);                                                 \
+    out++;                                                                    \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif  defined(PLT4_LE)
+#define FNAME(name) glz_plt4_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){                                \
+    uint8_t byte = *(in++);                                               \
+    uint32_t rgb = palette->ents[(byte & 0x0f) % (palette->num_ents)];    \
+    COPY_PLT_ENTRY(rgb, out);                                             \
+    out++;                                                                \
+    rgb = palette->ents[((byte >> 4) & 0x0f) % (palette->num_ents)];      \
+    COPY_PLT_ENTRY(rgb, out);                                             \
+    out++;                                                                \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif defined(PLT1_BE) // TODO store palette entries for direct access
+#define FNAME(name) glz_plt1_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){                                \
+    uint8_t byte = *(in++);                                               \
+    int i;                                                                \
+    uint32_t fore = palette->ents[1];                                     \
+    uint32_t back = palette->ents[0];                                     \
+    for (i = 7; i >= 0; i--)                                              \
+    {                                                                     \
+        if ((byte >> i) & 1) {                                            \
+            COPY_PLT_ENTRY(fore, out);                                    \
+        } else {                                                          \
+            COPY_PLT_ENTRY(back, out);                                    \
+        }                                                                 \
+        out++;                                                            \
+    }                                                                     \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#elif defined(PLT1_LE)
+#define FNAME(name) glz_plt1_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out, palette){                                \
+    uint8_t byte = *(in++);                                               \
+    int i;                                                                \
+    uint32_t fore = palette->ents[1];                                     \
+    uint32_t back = palette->ents[0];                                     \
+    for (i = 0; i < 8; i++)                                               \
+    {                                                                     \
+        if ((byte >> i) & 1) {                                            \
+            COPY_PLT_ENTRY(fore, out);                                    \
+        } else {                                                          \
+            COPY_PLT_ENTRY(back, out);                                    \
+        }                                                                 \
+        out++;                                                            \
+    }                                                                     \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#endif // PLT Type
+#endif // TO_RGB32
+#endif
+
+#ifdef LZ_RGB16
+#ifndef TO_RGB32
+#define OUT_PIXEL rgb16_pixel_t
+#define FNAME(name) glz_rgb16_##name
+#define COPY_COMP_PIXEL(in, out) {*out = (*(in++)) << 8; *out |= *(in++); out++;}
+#else
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb16_to_rgb32_##name
+#define COPY_COMP_PIXEL(in, out) {out->r = *(in++); out->b= *(in++);       \
+    out->g = (((out->r) << 6) | ((out->b) >> 2)) & ~0x07;                  \
+    out->g |= (out->g >> 5);                                               \
+    out->r = ((out->r << 1) & ~0x07) | ((out->r >> 4) & 0x07) ;            \
+    out->b = (out->b << 3) | ((out->b >> 2) & 0x07);                       \
+    out->pad = 0;                                                          \
+    out++;                                                                 \
+}                                                        
+#endif
+#endif
+
+#ifdef LZ_RGB24
+#define OUT_PIXEL rgb24_pixel_t
+#define FNAME(name) glz_rgb24_##name
+#define COPY_COMP_PIXEL(in, out) {  \
+    out->b = *(in++);               \
+    out->g = *(in++);               \
+    out->r = *(in++);               \
+    out++;                          \
+}
+#endif
+
+#ifdef LZ_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb32_##name
+#define COPY_COMP_PIXEL(in, out) {  \
+    out->b = *(in++);               \
+    out->g = *(in++);               \
+    out->r = *(in++);               \
+    out->pad = 0;                   \
+    out++;                          \
+}
+#endif
+
+#ifdef LZ_RGB_ALPHA
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb_alpha_##name
+#define COPY_PIXEL(p, out) {out->pad = p.pad; out++;}
+#define COPY_REF_PIXEL(ref, out) {out->pad = ref->pad; out++; ref++;}
+#define COPY_COMP_PIXEL(in, out) {out->pad = *(in++); out++;}
+#endif
+
+// TODO: seperate into routines that decode to dist,len. and to a routine that
+// actualy copies the data.
+
+/* returns num of bytes read from in buf.
+   size should be in PIXEL */
+static size_t FNAME(decode)(GlzDecoderWindow &window, uint8_t* in_buf,
+                            uint8_t *out_buf, int size,
+                            DecodedImageWinId image_win_id, Palette *plt,
+                            GlzDecoderDebug &debug_calls)
+{
+    uint8_t      *ip = in_buf;
+    OUT_PIXEL    *out_pix_buf = (OUT_PIXEL *)out_buf;
+    OUT_PIXEL    *op = out_pix_buf;
+    OUT_PIXEL    *op_limit = out_pix_buf + size;
+
+    uint32_t ctrl = *(ip++);
+    int loop = true;
+
+    do {
+        if (ctrl >= MAX_COPY) { // reference (dictionary/RLE)
+            OUT_PIXEL *ref = op;
+            uint32_t len = ctrl >> 5;
+            uint8_t pixel_flag = (ctrl >> 4) & 0x01;
+            uint32_t pixel_ofs = (ctrl & 0x0f);
+            uint8_t image_flag;
+            uint32_t image_dist;
+
+            /* retrieving the referenced images, the offset of the first pixel,
+               and the match length */
+
+            uint8_t code;
+            //len--; // TODO: why do we do this?
+
+            if (len == 7) { // match length is bigger than 7
+                do {
+                    code = *(ip++);
+                    len += code;
+                } while (code == 255); // remaining of len
+            }
+            code = *(ip++);
+            pixel_ofs += (code << 4);
+
+            code = *(ip++);
+            image_flag = (code >> 6) & 0x03;
+            if (!pixel_flag) { // short pixel offset
+                image_dist = code & 0x3f;
+                for (int i = 0; i < image_flag; i++) {
+                    code = *(ip++);
+                    image_dist += (code << (6 + (8 * i)));
+                }
+            } else {
+                pixel_flag = (code >> 5) & 0x01;
+                pixel_ofs += (code & 0x1f) << 12;
+                image_dist = 0;
+                for (int i = 0; i < image_flag; i++) {
+                    code = *(ip++);
+                    image_dist += (code << 8 * i);
+                }
+
+
+                if (pixel_flag) { // very long pixel offset
+                    code = *(ip++);
+                    pixel_ofs += code << 17;
+                }
+            }
+
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+            len += 2; // length is biased by 2 (fixing bias)
+#elif defined(LZ_RGB16)
+            len += 1; // length is biased by 1  (fixing bias)
+#endif
+            if (!image_dist) {
+                pixel_ofs += 1; // offset is biased by 1 (fixing bias)
+            }
+
+#if defined(TO_RGB32)
+#if defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || defined(PLT1_LE)
+            pixel_ofs = CAST_PLT_DISTANCE(pixel_ofs);
+            len = CAST_PLT_DISTANCE(len);
+#endif
+#endif
+
+            if (!image_dist) { // reference is inside the same image
+                ref -= pixel_ofs;
+                GLZ_ASSERT(debug_calls, ref + len <= op_limit);
+                GLZ_ASSERT(debug_calls, ref >= out_pix_buf);
+            } else {
+                ref = (OUT_PIXEL *)window.get_ref_pixel(image_win_id, image_dist,
+                                                        pixel_ofs);
+            }
+
+            GLZ_ASSERT(debug_calls, op + len <= op_limit);
+
+            /* copying the match*/
+
+            if (ref == (op - 1)) { // run (this will never be called in PLT4/1_TO_RGB because the
+                                  // number of pixel copied is larger then one...
+                /* optimize copy for a run */
+                OUT_PIXEL b = *ref;
+                for (; len; --len) {
+                    COPY_PIXEL(b, op);
+                    GLZ_ASSERT(debug_calls, op <= op_limit);
+                }
+            } else {
+                for (; len; --len) {
+                    COPY_REF_PIXEL(ref, op);
+                    GLZ_ASSERT(debug_calls, op <= op_limit);
+                }
+            }
+        } else { // copy
+            ctrl++; // copy count is biased by 1
+#if defined(TO_RGB32) && (defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || \
+                                                                                   defined(PLT1_LE))
+            GLZ_ASSERT(debug_calls, op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
+#else
+            GLZ_ASSERT(debug_calls, op + ctrl <= op_limit);
+#endif
+
+#if defined(TO_RGB32) && defined(LZ_PLT)
+            GLZ_ASSERT(debug_calls, plt);
+            COPY_COMP_PIXEL(ip, op, plt);
+#else
+            COPY_COMP_PIXEL(ip, op);
+#endif
+            GLZ_ASSERT(debug_calls, op <= op_limit);
+
+            for (--ctrl; ctrl; ctrl--) {
+#if defined(TO_RGB32) && defined(LZ_PLT)
+                GLZ_ASSERT(debug_calls, plt);
+                COPY_COMP_PIXEL(ip, op, plt);
+#else
+                COPY_COMP_PIXEL(ip, op);
+#endif
+                GLZ_ASSERT(debug_calls, op <= op_limit);
+            }
+        } // END REF/COPY
+
+        if (LZ_EXPECT_CONDITIONAL(op < op_limit)) {
+            ctrl = *(ip++);
+        } else {
+            loop = false;
+        }
+    } while (LZ_EXPECT_CONDITIONAL(loop));
+
+    return (ip - in_buf);
+}
+#undef LZ_PLT
+#undef PLT8
+#undef PLT4_BE
+#undef PLT4_LE
+#undef PLT1_BE
+#undef PLT1_LE
+#undef LZ_RGB16
+#undef LZ_RGB24
+#undef LZ_RGB32
+#undef LZ_RGB_ALPHA
+#undef TO_RGB32
+#undef OUT_PIXEL
+#undef FNAME
+#undef COPY_PIXEL
+#undef COPY_REF_PIXEL
+#undef COPY_COMP_PIXEL
+#undef COPY_PLT_ENTRY
+#undef CAST_PLT_DISTANCE
+
diff --git a/client/glz_decoded_image.h b/client/glz_decoded_image.h
new file mode 100644
index 00000000..4ed612f0
--- /dev/null
+++ b/client/glz_decoded_image.h
@@ -0,0 +1,65 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_DECODED_IMAGE
+#define _H_GLZ_DECODED_IMAGE
+
+#include "common.h"
+#include "glz_decoder_config.h"
+
+/*
+    This class represents an image the lz window holds. It is created after the decoding of the
+    image is completed, and destroyed when it exits the window.
+*/
+
+class GlzDecodedImage {
+public:
+
+    GlzDecodedImage(uint64_t id, uint64_t win_head_id, uint8_t *data, int size,
+                    int bytes_per_pixel)
+        : _id (id)
+        , _win_head_id (win_head_id)
+        , _data (data)
+        , _bytes_per_pixel (bytes_per_pixel)
+        , _size (size) {}
+
+    virtual ~GlzDecodedImage() {}
+    uint8_t *get_data() {return _data;}
+    uint8_t *get_pixel_ref(int offset); // pallete pix_id = byte count
+    uint64_t get_id() {return _id;}
+    uint64_t get_window_head_id() {return _win_head_id;}
+    int      get_size() {return _size;}
+
+protected:
+    uint64_t _id;
+    uint64_t _win_head_id;
+    uint8_t *_data;
+    int _bytes_per_pixel;  // if image is with palette pixel=byte
+    int _size;             // number of pixels
+};
+
+inline uint8_t* GlzDecodedImage::get_pixel_ref(int offset)
+{
+    if (!_data) {
+        return NULL;
+    } else {
+        return (_data + (offset * _bytes_per_pixel));
+    }
+}
+
+#endif
+
diff --git a/client/glz_decoder.cpp b/client/glz_decoder.cpp
new file mode 100644
index 00000000..d5f5970d
--- /dev/null
+++ b/client/glz_decoder.cpp
@@ -0,0 +1,290 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "glz_decoder_config.h"
+#include "glz_decoder.h"
+
+GlzDecoder::GlzDecoder(GlzDecoderWindow &images_window,
+                       GlzDecodeHandler &usr_handler, GlzDecoderDebug &debug_calls)
+    : _images_window (images_window)
+    , _usr_handler (usr_handler)
+    , _debug_calls (debug_calls)
+{
+}
+
+GlzDecoder::~GlzDecoder()
+{
+}
+
+void GlzDecoder::decode_header()
+{
+    int magic;
+    int version;
+    uint8_t tmp;
+    int stride;
+
+    magic = decode_32();
+    if (magic != LZ_MAGIC) {
+        _debug_calls.warn(std::string("bad magic\n"));
+    }
+
+    version = decode_32();
+    if (version != LZ_VERSION) {
+        _debug_calls.warn(std::string("bad version\n"));
+    }
+
+    tmp = *(_in_now++);
+
+    _image.type = (LzImageType)(tmp & LZ_IMAGE_TYPE_MASK);
+    _image.top_down = (tmp >> LZ_IMAGE_TYPE_LOG) ? true : false;
+    _image.width = decode_32();
+    _image.height = decode_32();
+    stride = decode_32();
+
+    if (IS_IMAGE_TYPE_PLT[_image.type]) {
+        _image.gross_pixels = stride * PLT_PIXELS_PER_BYTE[_image.type] * _image.height;
+    } else {
+        _image.gross_pixels = _image.width * _image.height;
+    }
+
+    _image.id = decode_64();
+    _image.win_head_dist = decode_32();
+}
+
+inline uint32_t GlzDecoder::decode_32()
+{
+    uint32_t word = 0;
+    word |= *(_in_now++);
+    word <<= 8;
+    word |= *(_in_now++);
+    word <<= 8;
+    word |= *(_in_now++);
+    word <<= 8;
+    word |= *(_in_now++);
+    return word;
+}
+
+inline uint64_t GlzDecoder::decode_64()
+{
+    uint64_t long_word = decode_32();
+    long_word <<= 32;
+    long_word |= decode_32();
+    return long_word;
+}
+
+// TODO: the code is historically c based. Consider transforming to c++ and use templates
+//      - but be sure it won't make it slower!
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
+#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
+#else
+#define LZ_EXPECT_CONDITIONAL(c) (c)
+#define LZ_UNEXPECT_CONDITIONAL(c) (c)
+#endif
+
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#define ATTR_PACKED
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+
+/* the palette images will be treated as one byte pixels. Their width should be transformed
+   accordingly.
+*/
+typedef struct ATTR_PACKED one_byte_pixel_t {
+    uint8_t a;
+} one_byte_pixel_t;
+
+typedef struct ATTR_PACKED rgb32_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t pad;
+} rgb32_pixel_t;
+
+typedef struct ATTR_PACKED rgb24_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#define LZ_PLT
+#include "glz_decode_tmpl.c"
+
+#define LZ_PLT
+#define PLT8
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_PLT
+#define PLT4_BE
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_PLT
+#define PLT4_LE
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_PLT
+#define PLT1_BE
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_PLT
+#define PLT1_LE
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+
+#define LZ_RGB16
+#include "glz_decode_tmpl.c"
+#define LZ_RGB16
+#define TO_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_RGB24
+#include "glz_decode_tmpl.c"
+
+#define LZ_RGB32
+#include "glz_decode_tmpl.c"
+
+#define LZ_RGB_ALPHA
+#include "glz_decode_tmpl.c"
+
+#undef LZ_UNEXPECT_CONDITIONAL
+#undef LZ_EXPECT_CONDITIONAL
+
+typedef size_t (*decode_function)(GlzDecoderWindow &window, uint8_t* in_buf,
+                                  uint8_t *out_buf, int size,
+                                  DecodedImageWinId image_win_id, Palette *plt,
+                                  GlzDecoderDebug  &debug_calls);
+
+// ordered according to LZ_IMAGE_TYPE
+const decode_function DECODE_TO_RGB32[] = {
+    NULL,
+    glz_plt1_le_to_rgb32_decode,
+    glz_plt1_be_to_rgb32_decode,
+    glz_plt4_le_to_rgb32_decode,
+    glz_plt4_be_to_rgb32_decode,
+    glz_plt8_to_rgb32_decode,
+    glz_rgb16_to_rgb32_decode,
+    glz_rgb32_decode,
+    glz_rgb32_decode,
+    glz_rgb32_decode
+};
+
+const decode_function DECODE_TO_SAME[] = {
+    NULL,
+    glz_plt_decode,
+    glz_plt_decode,
+    glz_plt_decode,
+    glz_plt_decode,
+    glz_plt_decode,
+    glz_rgb16_decode,
+    glz_rgb24_decode,
+    glz_rgb32_decode,
+    glz_rgb32_decode
+};
+
+void GlzDecoder::decode(uint8_t *data, Palette *palette, void *opaque_usr_info)
+{
+    int out_size;
+    DecodedImageWinId image_window_id;
+    GlzDecodedImage *decoded_image;
+    size_t n_in_bytes_decoded;
+    int bytes_per_pixel;
+    LzImageType decoded_type;
+
+    _in_start = data;
+    _in_now = data;
+
+    decode_header();
+
+#ifdef GLZ_DECODE_TO_RGB32
+    out_size = _image.gross_pixels << 2;
+    bytes_per_pixel = 4;
+
+    if (_image.type == LZ_IMAGE_TYPE_RGBA) {
+        decoded_type = LZ_IMAGE_TYPE_RGBA;
+    } else {
+        decoded_type = LZ_IMAGE_TYPE_RGB32;
+    }
+
+#else
+    if (IS_IMAGE_TYPE_PLT[_image.type]) {
+        GLZ_ASSERT(_debug_calls, !(_image.gross_pixels % PLT_PIXELS_PER_BYTE[_image.type]));
+        out_size = _image.gross_pixels / PLT_PIXELS_PER_BYTE[_image.type];
+    } else {
+        out_size = _image.gross_pixels * RGB_BYTES_PER_PIXEL[_image.type];
+    }
+    bytes_per_pixel = RGB_BYTES_PER_PIXEL[_image.type];
+    decoded_type = _image.type;
+#endif
+
+
+    image_window_id = _images_window.pre_decode(_image.id, _image.id - _image.win_head_dist);
+
+    decoded_image = _usr_handler.alloc_image(opaque_usr_info, _image.id,
+                                             _image.id - _image.win_head_dist,
+                                             decoded_type, _image.width, _image.height,
+                                             _image.gross_pixels, bytes_per_pixel,
+                                             _image.top_down);
+
+    _image.data = decoded_image->get_data();
+
+    // decode_by_type
+#ifdef GLZ_DECODE_TO_RGB32
+    n_in_bytes_decoded = DECODE_TO_RGB32[_image.type](_images_window, _in_now, _image.data,
+                                                      _image.gross_pixels, image_window_id,
+                                                      palette, _debug_calls);
+#else
+    n_in_bytes_decoded = DECODE_TO_SAME[_image.type](_images_window, _in_now, _image.data,
+                                                     IS_IMAGE_TYPE_PLT[_image.type] ?
+                                                     _image.gross_pixels /
+                                                     PLT_PIXELS_PER_BYTE[_image.type] :
+                                                     _image.gross_pixels,
+                                                     image_window_id, palette, _debug_calls);
+#endif
+
+    _in_now += n_in_bytes_decoded;
+
+    if (_image.type == LZ_IMAGE_TYPE_RGBA) {
+        glz_rgb_alpha_decode(_images_window, _in_now, _image.data,
+                             _image.gross_pixels, image_window_id, palette, _debug_calls);
+    }
+
+    _images_window.post_decode(decoded_image);
+}
+
diff --git a/client/glz_decoder.h b/client/glz_decoder.h
new file mode 100644
index 00000000..98c15754
--- /dev/null
+++ b/client/glz_decoder.h
@@ -0,0 +1,86 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_DECODER
+#define _H_GLZ_DECODER
+
+#include "lz_common.h"
+#include "glz_decoder_config.h"
+#include "glz_decoder_window.h"
+#include "draw.h"
+
+
+
+class GlzDecodeHandler {
+public:
+    GlzDecodeHandler() {}
+    virtual ~GlzDecodeHandler() {}
+
+    /* Called by the decoder before the image decoding is starts. The
+       user of the decoder should create GlzDecodedImage instance.
+       If resources should be released when the image exits the Glz window,
+       it should be handled in the instance dtor.
+
+       opaque_usr_info: the data sent when GlzDecoder::decode was called
+       gross_pixels   : number of pixels when considering the whole stride*/
+    virtual GlzDecodedImage *alloc_image(void *opaque_usr_info, uint64_t image_id,
+                                         uint64_t image_win_head_id, LzImageType type,
+                                         int width, int height, int gross_pixels,
+                                         int n_bytes_per_pixel, bool top_down) = 0;
+};
+
+/*
+    This class implements the lz decoding algorithm
+*/
+
+class GlzDecoder {
+public:
+
+    GlzDecoder(GlzDecoderWindow &images_window, GlzDecodeHandler &usr_handler,
+               GlzDecoderDebug &debug_calls);
+    virtual ~GlzDecoder();
+
+    /* Decodes the data and afterwards  calls GlzDecodeHandler::handle_decoded_image */
+    void decode(uint8_t *data, Palette *palette, void *opaque_usr_info);
+
+private:
+    void decode_header();
+    uint32_t decode_32();
+    uint64_t decode_64();
+
+private:
+    GlzDecoderWindow &_images_window;
+    GlzDecodeHandler &_usr_handler;
+    GlzDecoderDebug  &_debug_calls;
+
+    uint8_t *_in_now;
+    uint8_t *_in_start;
+
+    struct {
+        uint64_t id;
+        LzImageType type;
+        int width;
+        int height;
+        int gross_pixels;
+        bool top_down;
+        int win_head_dist;
+        uint8_t *data;
+    } _image;
+};
+
+#endif // _H_GLZ_DECODER
+
diff --git a/client/glz_decoder_config.h b/client/glz_decoder_config.h
new file mode 100644
index 00000000..44ef1653
--- /dev/null
+++ b/client/glz_decoder_config.h
@@ -0,0 +1,85 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_DECODER_CONFIG
+#define _H_GLZ_DECODER_CONFIG
+
+#include <exception>
+#include <sstream>
+
+#include "lz_common.h"
+
+#include <stdio.h>
+
+#ifdef __GNUC__
+
+#include <stdint.h>
+
+
+#else
+
+#include <stddef.h>
+#include <basetsd.h>
+
+
+typedef UINT64 uint64_t;
+typedef UINT32 uint32_t;
+typedef UINT16 uint16_t;
+typedef UINT8 uint8_t;
+
+#endif  //__GNUC__
+
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+
+class GlzException: public std::exception {
+public:
+    GlzException(const std::string& str) : _mess (str) {}
+    virtual ~GlzException() throw () {}
+    virtual const char* what() const throw () {return _mess.c_str();}
+
+private:
+    std::string _mess;
+};
+
+class GlzDecoderDebug {
+public:
+    virtual ~GlzDecoderDebug() {}
+    virtual void error(const std::string& str) = 0;
+    virtual void warn(const std::string& str) = 0;
+    virtual void info(const std::string& str) = 0;
+};
+
+#ifdef RED_DEBUG
+
+#define GLZ_ASSERT(debug, x) {						                    \
+    if (!(x)) {								                            \
+	std::ostringstream os;						                        \
+        os << __FUNCTION__ << ": ASSERT " << #x << " failed\n";		    \
+        (debug).error(os.str());					                    \
+    }									                                \
+}
+#else
+
+#define GLZ_ASSERT(debug, x)
+
+#endif
+
+#define GLZ_DECODE_TO_RGB32
+
+#endif  //_H_GLZ_DECODER_CONFIG
+
diff --git a/client/glz_decoder_window.cpp b/client/glz_decoder_window.cpp
new file mode 100644
index 00000000..9cd64abd
--- /dev/null
+++ b/client/glz_decoder_window.cpp
@@ -0,0 +1,358 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+
+#include "glz_decoder_window.h"
+#include "utils.h"
+
+#define INIT_IMAGES_CAPACITY 100
+#define WIN_OVERFLOW_FACTOR 1.5
+#define WIN_REALLOC_FACTOR 1.5
+
+GlzDecoderWindow::GlzDecoderWindow(int pixels_capacity, GlzDecoderDebug &debug_calls)
+    : _pixels_capacity (pixels_capacity)
+    , _aborting (false)
+    , _debug_calls (debug_calls)
+{
+    if (_pixels_capacity > LZ_MAX_WINDOW_SIZE) {
+        std::string erro_str;
+        string_printf(erro_str, "Glz Window capacity exceeds the limit %d",
+                      _pixels_capacity);
+        _debug_calls.error(erro_str);
+    }
+
+    _images_capacity = INIT_IMAGES_CAPACITY;
+    _images = new  GlzDecodedImage*[_images_capacity];
+    if (!_images) {
+        _debug_calls.error(std::string("failed allocating images\n"));
+    }
+
+    memset(_images, 0, sizeof(GlzDecodedImage*) * _images_capacity);
+
+    init();
+}
+
+GlzDecoderWindow::~GlzDecoderWindow()
+{
+    clear();
+    delete _images;
+}
+
+DecodedImageWinId GlzDecoderWindow::pre_decode(uint64_t image_id, uint64_t relative_head_id)
+{
+    DecodedImageWinId image_win_id = pre_decode_update_window(image_id, relative_head_id);
+    pre_decode_finalize();
+    return image_win_id;
+}
+
+void GlzDecoderWindow::post_decode(GlzDecodedImage *image)
+{
+    post_decode_intialize();
+    post_decode_update_window(image);
+}
+
+/* index: the physical index in the images array. Note that it can't change between waits since
+   the realloc mutex should be read locked.
+   No starvation for the realloc mutex can occure, since the image we wait for is located before us,
+   hence, when it arrives - no realloc is needed. */
+void GlzDecoderWindow::wait_for_image(int index)
+{
+    Lock lock(_new_image_mutex);
+    GlzDecodedImage *image = _images[index]; // can be performed without locking the _win_mutex,
+                                             // since it is called after pre and the rw mutex is                                                 // locked, hence, physical chnages to the window are
+                                             // not allowed. In addtion the reading of the image ptr
+                                             // is atomic, thus, even if the value changes we are
+                                             // not affected.
+
+    while (!image) {
+        if (_aborting) {
+            THROW("aborting");
+        }
+        _new_image_cond.wait(lock);
+        image = _images[index];
+    }
+}
+
+void GlzDecoderWindow::abort()
+{
+    Lock lock1(_win_modifiers_mutex);
+    Lock lock2(_new_image_mutex);
+    _aborting = true;
+    _new_image_cond.notify_all();
+    _release_image_cond.notify_all();
+    _win_alloc_cond.notify_all();
+}
+
+void GlzDecoderWindow::clear()
+{
+    Lock lock(_win_modifiers_mutex);
+    release_images();
+    init();
+}
+
+void GlzDecoderWindow::set_pixels_capacity(int pixels_capacity)
+{
+    Lock lock(_win_modifiers_mutex);
+
+    if (pixels_capacity > LZ_MAX_WINDOW_SIZE) {
+        std::string erro_str;
+        string_printf(erro_str, "Glz Window capacity exceeds the limit %d",
+                      pixels_capacity);
+        _debug_calls.error(erro_str);
+    }
+    _pixels_capacity = pixels_capacity;
+}
+
+void GlzDecoderWindow::init()
+{
+    _missing_list.clear();
+    // The window is never empty: the head is in the missing list or in the window.
+    // The first missing image is 0.
+    _missing_list.push_front(0);
+    _head_idx = 0;
+    _tail_image_id = 0;
+    _n_images = 1;
+    _n_pixels = 0;
+}
+
+void GlzDecoderWindow::release_images()
+{
+    for (int i = 0; i < _n_images; i++) {
+        int idx = (_head_idx + i) % _images_capacity;
+        if (_images[idx]) {
+            delete _images[idx];
+            _images[idx] = NULL;
+        }
+    }
+}
+
+inline bool GlzDecoderWindow::is_empty()
+{
+    return (!_n_images);
+}
+
+/* aprroximated overflow. Considers only the size that currently occupies the window and
+   not the size of the missing images. TODO: consider other measures */
+inline bool GlzDecoderWindow::will_overflow(uint64_t image_id, uint64_t relative_head_id)
+{
+    if (image_id <= _tail_image_id) {
+        return false;
+    }
+
+    if (_n_pixels > (WIN_OVERFLOW_FACTOR * _pixels_capacity)) {
+        return true;
+    }
+
+    if (!_missing_list.empty() && (_missing_list.front() < relative_head_id)) {
+        // two non overlapping windows
+        return true;
+    }
+
+    return false;
+}
+
+DecodedImageWinId GlzDecoderWindow::pre_decode_update_window(uint64_t image_id,
+                                                             uint64_t relative_head_id)
+{
+    Lock lock(_win_modifiers_mutex);
+    int realloc_size;
+
+    while (will_overflow(image_id, relative_head_id)) {
+        if (_aborting) {
+            THROW("aborting");
+        }
+        _release_image_cond.wait(lock);
+    }
+
+    // The following conditions prevent starvation in case thread (1) should realloc,
+    // thread (2) is during decode and waits for a previous image and
+    /// thread (3) should decode this the previous image and needs to enter pre decode although
+    // (1) is in there.
+    // We must give priority to older images in the window.
+    // The condition should be checked over again in case a later image entered the window
+    // and the realocation was already performed
+    while ((realloc_size = calc_realloc_size(image_id))) {
+        if (_aborting) {
+            THROW("aborting");
+        }
+
+        if (_win_alloc_rw_mutex.try_write_lock()) {
+            realloc(realloc_size);
+            _win_alloc_rw_mutex.write_unlock();
+            break;
+        } else {
+            _win_alloc_cond.wait(lock);
+        }
+    }
+
+    if (image_id > _tail_image_id) { // not in missing list
+        add_pre_decoded_image(image_id);
+    }
+
+    return calc_image_win_idx(image_id);
+}
+
+void GlzDecoderWindow::add_pre_decoded_image(uint64_t image_id)
+{
+    GLZ_ASSERT(_debug_calls, image_id > _tail_image_id);
+    GLZ_ASSERT(_debug_calls, image_id - _tail_image_id + _n_images < _images_capacity);
+
+    for (uint64_t miss_id = _tail_image_id + 1; miss_id <= image_id; miss_id++) {
+        _missing_list.push_back(miss_id);
+        _n_images++;
+    }
+    _tail_image_id = image_id;
+}
+
+inline int GlzDecoderWindow::calc_realloc_size(uint64_t new_tail_image_id)
+{
+    if (new_tail_image_id <= _tail_image_id) {
+        return 0;
+    }
+
+    int min_capacity = (int)(_n_images + new_tail_image_id - _tail_image_id);
+
+    if ((min_capacity * WIN_REALLOC_FACTOR) > _images_capacity) {
+        return (int)MAX(min_capacity * WIN_REALLOC_FACTOR, WIN_REALLOC_FACTOR * _images_capacity);
+    } else {
+        return 0;
+    }
+}
+
+void GlzDecoderWindow::realloc(int size)
+{
+    GlzDecodedImage **new_images = new GlzDecodedImage*[size];
+
+    if (!new_images) {
+        _debug_calls.error(std::string("failed allocating images array"));
+    }
+    memset(new_images, 0, sizeof(GlzDecodedImage*) * size);
+
+    for (int i = 0; i < _n_images; i++) {
+        new_images[i] = _images[(i + _head_idx) % _images_capacity];
+    }
+    delete _images;
+
+    _images = new_images;
+    _head_idx = 0;
+    _images_capacity = size;
+}
+
+void GlzDecoderWindow::pre_decode_finalize()
+{
+    _win_alloc_rw_mutex.read_lock();
+}
+
+void GlzDecoderWindow::post_decode_intialize()
+{
+    _win_alloc_rw_mutex.read_unlock();
+}
+
+void GlzDecoderWindow::post_decode_update_window(GlzDecodedImage *image)
+{
+    Lock lock(_win_modifiers_mutex);
+    add_decoded_image(image);
+    narrow_window(image);
+    _win_alloc_cond.notify_all();
+}
+
+void GlzDecoderWindow::add_decoded_image(GlzDecodedImage *image)
+{
+    Lock lock(_new_image_mutex);
+    GLZ_ASSERT(_debug_calls, image->get_id() <= _tail_image_id);
+    _images[calc_image_win_idx(image->get_id())] = image;
+    _n_pixels += image->get_size();
+    _new_image_cond.notify_all();
+}
+
+/* Important observations:
+   1) When an image is added, if it is not the first missing image, it is not removed
+      immediately from the missing list (in order not to store another pointer to
+      the missing list inside the window ,or otherwise, to go over the missing list
+      and look for the image).
+   2) images that weren't removed from the missing list in their addition time, will be removed when
+      preliminary images will be added.
+   3) The first item in the missing list is always really missing.
+   4) The missing list is always ordered by image id (see add_pre_decoded_image)
+*/
+void GlzDecoderWindow::narrow_window(GlzDecodedImage *last_added)
+{
+    uint64_t new_head_image_id;
+
+    GLZ_ASSERT(_debug_calls, !_missing_list.empty());
+
+    if (_missing_list.front() != last_added->get_id()) {
+        return;
+    }
+
+    _missing_list.pop_front();  // removing the last added image from the missing list
+
+    /* maintaing the missing list: removing front images that already arrived */
+    while (!_missing_list.empty()) {
+        int front_win_idx = calc_image_win_idx(_missing_list.front());
+        if (_images[front_win_idx] == NULL) { // still missing
+            break;
+        } else {
+            _missing_list.pop_front();
+        }
+    }
+
+    /* removing unnecessary image from the window's head*/
+    if (_missing_list.empty()) {
+        new_head_image_id = _images[
+                calc_image_win_idx(_tail_image_id)]->get_window_head_id();
+    } else {
+        // there must be at least one image in the window since narrow_window is called
+        // from post decode
+        GLZ_ASSERT(_debug_calls, _images[calc_image_win_idx(_missing_list.front() - 1)]);
+        new_head_image_id = _images[
+                calc_image_win_idx(_missing_list.front() - 1)]->get_window_head_id();
+    }
+
+    remove_head(new_head_image_id);
+}
+
+inline void GlzDecoderWindow::remove_head(uint64_t new_head_image_id)
+{
+    GLZ_ASSERT(_debug_calls, _images[_head_idx]);
+
+    int n_images_remove = (int)(new_head_image_id - _images[_head_idx]->get_id());
+
+    if (!n_images_remove) {
+        return;
+    }
+
+    for (int i = 0; i < n_images_remove; i++) {
+        int index = (_head_idx + i) % _images_capacity;
+        _n_pixels -= _images[index]->get_size();
+        delete _images[index];
+        _images[index] = NULL;
+    }
+
+    _n_images -= n_images_remove;
+    _head_idx = (_head_idx + n_images_remove) % _images_capacity;
+
+    _release_image_cond.notify_all();
+}
+
+/* NOTE: can only be used when the window is locked. (i.e, not inside get_ref_pixel) */
+inline int GlzDecoderWindow::calc_image_win_idx(uint64_t image_id)
+{
+    return (int)((_head_idx + _n_images - 1 - (_tail_image_id - image_id)) % _images_capacity);
+}
+
diff --git a/client/glz_decoder_window.h b/client/glz_decoder_window.h
new file mode 100644
index 00000000..831f2d56
--- /dev/null
+++ b/client/glz_decoder_window.h
@@ -0,0 +1,127 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_DECODER_WINDOW
+#define _H_GLZ_DECODER_WINDOW
+
+#include "glz_decoder_config.h"
+#include "glz_decoded_image.h"
+
+#include <list>
+
+#include "read_write_mutex.h"
+
+typedef int DecodedImageWinId;
+
+/*
+    The class represents the lz window of images, which is shared among the glz decoders
+*/
+
+class GlzDecoderWindow {
+public:
+    GlzDecoderWindow(int pixels_capacity, GlzDecoderDebug &debug_calls);
+    virtual ~GlzDecoderWindow();
+
+    DecodedImageWinId pre_decode(uint64_t image_id, uint64_t relative_head_id);
+
+    void post_decode(GlzDecodedImage *image);
+
+    /* NOTE - get_ref_pixel should be called only after pre_decode was called and
+       before post decode was called */
+    uint8_t *get_ref_pixel(DecodedImageWinId decoded_image_win_id, int dist_from_ref_image,
+                           int pixel_offset);
+
+    void abort();
+
+    /* NOTE - clear mustn't be called if the window is currently used by a decoder*/
+    void clear();
+
+    void set_pixels_capacity(int pixels_capacity);
+
+private:
+    void wait_for_image(int index);
+    void add_image(GlzDecodedImage *image);
+    uint8_t* get_pixel_after_image_entered(int image_index, int pixel_offset);
+
+    bool will_overflow(uint64_t image_id, uint64_t relative_head_id);
+    bool is_empty();
+
+    DecodedImageWinId pre_decode_update_window(uint64_t image_id, uint64_t relative_head_id);
+    void pre_decode_finalize();
+    void post_decode_intialize();
+    void post_decode_update_window(GlzDecodedImage *image);
+    void add_pre_decoded_image(uint64_t image_id);
+    void add_decoded_image(GlzDecodedImage *image);
+    void narrow_window(GlzDecodedImage *last_added);
+    void remove_head(uint64_t new_head_image_id);
+    int  calc_image_win_idx(uint64_t image_id);
+    int  calc_realloc_size(uint64_t new_tail_image_id);
+    void realloc(int size);
+    void init();
+    void release_images();
+
+private:
+    int _pixels_capacity;
+    GlzDecodedImage **_images; // cyclic window
+    int _head_idx;            // index in images array (not image id)
+    uint64_t _tail_image_id;
+    int _images_capacity;
+    int _n_images;            // _n_images counts all the images in
+                              // the window, including the missing ones
+    uint64_t _n_pixels;
+
+    std::list<uint64_t> _missing_list;
+
+    Mutex _win_modifiers_mutex;
+    ReadWriteMutex _win_alloc_rw_mutex;
+    Mutex _new_image_mutex;
+
+    Condition _new_image_cond;          // when get_pixel_ref waits for an image
+    Condition _release_image_cond;      // when waiting for the window to narrow.
+    Condition _win_alloc_cond;
+
+    bool _aborting;
+
+    GlzDecoderDebug &_debug_calls;
+};
+
+inline uint8_t* GlzDecoderWindow::get_pixel_after_image_entered(int image_index,
+                                                                int pixel_offset)
+{
+    return _images[image_index]->get_pixel_ref(pixel_offset);
+}
+
+/* should be called only between pre and post (when realloc mutex is write-locked).
+   Note that it can't use calc_image_win_idx, since the window is not locked for changes
+   (that are not reallocation) during decoding.*/
+inline uint8_t *GlzDecoderWindow::get_ref_pixel(DecodedImageWinId decoded_image_win_id,
+                                                int dist_from_ref_image, int pixel_offset)
+{
+    int ref_image_index = (dist_from_ref_image <= decoded_image_win_id) ?
+        (decoded_image_win_id - dist_from_ref_image) :
+        _images_capacity + (decoded_image_win_id - dist_from_ref_image);
+
+    if (_images[ref_image_index] == NULL) { // reading image is atomic
+        wait_for_image(ref_image_index);
+    }
+
+    // after image entered - it won't leave the window till no decoder needs it
+    return get_pixel_after_image_entered(ref_image_index, pixel_offset);
+}
+
+#endif // _H_GLZ_DECODER_WINDOW
+
diff --git a/client/hot_keys.cpp b/client/hot_keys.cpp
new file mode 100644
index 00000000..0e43d27a
--- /dev/null
+++ b/client/hot_keys.cpp
@@ -0,0 +1,147 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "hot_keys.h"
+#include "utils.h"
+#include "debug.h"
+
+HotKeysParser::HotKeysParser(const std::string& hotkeys, const CommandsMap& commands_map)
+{
+    DBG(0, "hotkeys = %s", hotkeys.c_str());
+
+    std::istringstream is(hotkeys);
+    std::string hotkey;
+    while (std::getline(is, hotkey, ',')) {
+        add_hotkey(hotkey, commands_map);
+    }
+}
+
+void HotKeysParser::parse_keys(int command_id, const std::string& hotkey)
+{
+    HotkeySet& keys = _hot_keys[command_id];
+    std::istringstream is(hotkey);
+    std::string key;
+    while (std::getline(is, key, '+')) {
+        add_key(keys, key.c_str());
+    }
+}
+
+void HotKeysParser::add_key(HotkeySet& keys, const char* key)
+{
+    ASSERT(key != NULL);
+
+    static const struct {
+        const char* name;
+        RedKey main;
+        RedKey alter;
+    } keyboard[] = {
+        { "alt", REDKEY_R_ALT, REDKEY_L_ALT },
+        { "ralt", REDKEY_R_ALT, REDKEY_INVALID },
+        { "rightalt", REDKEY_R_ALT, REDKEY_INVALID },
+        { "right-alt", REDKEY_R_ALT, REDKEY_INVALID },
+        { "lalt", REDKEY_L_ALT, REDKEY_INVALID },
+        { "leftalt", REDKEY_L_ALT, REDKEY_INVALID },
+        { "left-alt", REDKEY_L_ALT, REDKEY_INVALID },
+        { "ctrl", REDKEY_R_CTRL, REDKEY_L_CTRL },
+        { "rctrl", REDKEY_R_CTRL, REDKEY_INVALID },
+        { "rightctrl", REDKEY_R_CTRL, REDKEY_INVALID },
+        { "right-ctrl", REDKEY_R_CTRL, REDKEY_INVALID },
+        { "lctrl", REDKEY_L_CTRL, REDKEY_INVALID },
+        { "leftctrl", REDKEY_L_CTRL, REDKEY_INVALID },
+        { "left-ctrl", REDKEY_L_CTRL, REDKEY_INVALID },
+        { "shift", REDKEY_R_SHIFT, REDKEY_L_SHIFT },
+        { "rshift", REDKEY_R_SHIFT, REDKEY_INVALID },
+        { "rightshift", REDKEY_R_SHIFT, REDKEY_INVALID },
+        { "right-shift", REDKEY_R_SHIFT, REDKEY_INVALID },
+        { "lshift", REDKEY_L_SHIFT, REDKEY_INVALID },
+        { "leftshift", REDKEY_L_SHIFT, REDKEY_INVALID },
+        { "left-shift", REDKEY_L_SHIFT, REDKEY_INVALID },
+        { "cmd", REDKEY_RIGHT_CMD, REDKEY_LEFT_CMD },
+        { "rcmd", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "rightcmd", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "right-cmd", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "lcmd", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "leftcmd", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "left-cmd", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "win", REDKEY_RIGHT_CMD, REDKEY_LEFT_CMD },
+        { "rwin", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "rightwin", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "right-win", REDKEY_RIGHT_CMD, REDKEY_INVALID },
+        { "lwin", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "leftwin", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "left-win", REDKEY_LEFT_CMD, REDKEY_INVALID },
+        { "esc", REDKEY_ESCAPE, REDKEY_INVALID },
+        { "escape", REDKEY_ESCAPE, REDKEY_INVALID },
+        { "ins", REDKEY_INSERT, REDKEY_INVALID },
+        { "insert", REDKEY_INSERT, REDKEY_INVALID },
+        { "del", REDKEY_DELETE, REDKEY_INVALID },
+        { "delete", REDKEY_DELETE, REDKEY_INVALID },
+        { "pgup", REDKEY_PAGEUP, REDKEY_INVALID },
+        { "pageup", REDKEY_PAGEUP, REDKEY_INVALID },
+        { "pgdn", REDKEY_PAGEDOWN, REDKEY_INVALID },
+        { "pagedown", REDKEY_PAGEDOWN, REDKEY_INVALID },
+        { "home", REDKEY_HOME, REDKEY_INVALID },
+        { "end", REDKEY_END, REDKEY_INVALID },
+        { "space", REDKEY_SPACE, REDKEY_INVALID },
+        { "enter", REDKEY_ENTER, REDKEY_INVALID },
+        { "tab", REDKEY_TAB, REDKEY_INVALID },
+        { "f1", REDKEY_F1, REDKEY_INVALID },
+        { "f2", REDKEY_F2, REDKEY_INVALID },
+        { "f3", REDKEY_F3, REDKEY_INVALID },
+        { "f4", REDKEY_F4, REDKEY_INVALID },
+        { "f5", REDKEY_F5, REDKEY_INVALID },
+        { "f6", REDKEY_F6, REDKEY_INVALID },
+        { "f7", REDKEY_F7, REDKEY_INVALID },
+        { "f8", REDKEY_F8, REDKEY_INVALID },
+        { "f9", REDKEY_F9, REDKEY_INVALID },
+        { "f10", REDKEY_F10, REDKEY_INVALID },
+        { "f11", REDKEY_F11, REDKEY_INVALID },
+        { "f12", REDKEY_F12, REDKEY_INVALID }
+    };
+
+    for (int i = 0; i < (sizeof(keyboard) / sizeof(keyboard[0])); ++i) {
+        if (strcasecmp(key, keyboard[i].name) == 0) {
+            HotkeyKey hotkey;
+            hotkey.main = keyboard[i].main;
+            hotkey.alter = keyboard[i].alter;
+            DBG(0, "keys = %s", keyboard[i].name);
+            keys.push_back(hotkey);
+            return;
+        }
+    }
+    THROW("unknown key name %s", key);
+}
+
+void HotKeysParser::add_hotkey(const std::string& hotkey, const CommandsMap& commands_map)
+{
+    std::string::size_type key_start = hotkey.find('=', 0);
+    if (key_start == std::string::npos) {
+        THROW("unable to parse hot keys");
+    }
+    std::string command_name = hotkey.substr(0, key_start);
+
+    CommandsMap::const_iterator command = commands_map.find(command_name);
+
+    if (commands_map.find(command_name) == commands_map.end()) {
+        THROW("invalid action bname");
+    }
+    int command_id = commands_map.find(command_name)->second;
+    std::string keys = hotkey.substr(key_start + 1);
+    parse_keys(command_id, keys);
+}
+
diff --git a/client/hot_keys.h b/client/hot_keys.h
new file mode 100644
index 00000000..15016f13
--- /dev/null
+++ b/client/hot_keys.h
@@ -0,0 +1,49 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_HOT_KEYS
+#define _H_HOT_KEYS
+
+#include "common.h"
+#include "red_key.h"
+
+typedef std::map<std::string, int> CommandsMap;
+
+struct HotkeyKey {
+    RedKey main;
+    RedKey alter;
+};
+
+typedef std::vector<HotkeyKey> HotkeySet;
+typedef std::map<int, HotkeySet> HotKeys;
+
+class HotKeysParser {
+public:
+    HotKeysParser(const std::string& hotkeys, const CommandsMap& commands_map);
+    const HotKeys& get() { return _hot_keys;}
+
+private:
+    void add_hotkey(const std::string& hotkey, const CommandsMap& commands_map);
+    void parse_keys(int command_id, const std::string& hotkey);
+    void add_key(HotkeySet& keys, const char* key);
+
+private:
+    HotKeys _hot_keys;
+};
+
+#endif
+
diff --git a/client/icon.h b/client/icon.h
new file mode 100644
index 00000000..96027560
--- /dev/null
+++ b/client/icon.h
@@ -0,0 +1,36 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_ICON
+#define _H_ICON
+
+class Icon {
+public:
+    Icon() : _refs (1) {}
+
+    Icon* ref() { _refs++; return this;}
+    void unref() { if (!--_refs) delete this;}
+
+protected:
+    virtual ~Icon() {}
+
+private:
+    int _refs;
+};
+
+#endif
+
diff --git a/client/inputs_channel.cpp b/client/inputs_channel.cpp
new file mode 100644
index 00000000..8035bfb3
--- /dev/null
+++ b/client/inputs_channel.cpp
@@ -0,0 +1,360 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "inputs_channel.h"
+#include "utils.h"
+#include "debug.h"
+#include "red_client.h"
+#include "application.h"
+
+#define SYNC_REMOTH_MODIFIRES
+
+class SetInputsHandlerEvent: public Event {
+public:
+    SetInputsHandlerEvent(InputsChannel& channel) : _channel (channel) {}
+
+    virtual void responce(Application& application)
+    {
+        application.set_inputs_handler(_channel);
+    }
+
+private:
+    InputsChannel& _channel;
+};
+
+class KeyModifiersEvent: public Event {
+public:
+    KeyModifiersEvent(InputsChannel& channel) : _channel (channel) {}
+
+    virtual void responce(Application& application)
+    {
+        Lock lock(_channel._update_modifiers_lock);
+        _channel._active_modifiers_event = false;
+        _channel.set_local_modifiers();
+    }
+
+private:
+    InputsChannel& _channel;
+};
+
+class RemoveInputsHandlerEvent: public SyncEvent {
+public:
+    RemoveInputsHandlerEvent(InputsChannel& channel) : _channel (channel) {}
+
+    virtual void do_responce(Application& application)
+    {
+        application.remove_inputs_handler(_channel);
+    }
+
+private:
+    InputsChannel& _channel;
+};
+
+class MotionMessage: public RedChannel::OutMessage, public RedPeer::OutMessage {
+public:
+    MotionMessage(InputsChannel& channel);
+    virtual RedPeer::OutMessage& peer_message();
+    virtual void release();
+
+private:
+    InputsChannel& _channel;
+};
+
+MotionMessage::MotionMessage(InputsChannel& channel)
+    : RedChannel::OutMessage()
+    , RedPeer::OutMessage(REDC_INPUTS_MOUSE_MOTION, sizeof(RedcMouseMotion))
+    , _channel (channel)
+{
+}
+
+void MotionMessage::release()
+{
+    delete this;
+}
+
+RedPeer::OutMessage& MotionMessage::peer_message()
+{
+    _channel.set_motion_event(*(RedcMouseMotion*)data());
+    return *this;
+}
+
+class PositionMessage: public RedChannel::OutMessage, public RedPeer::OutMessage {
+public:
+    PositionMessage(InputsChannel& channel);
+    virtual RedPeer::OutMessage& peer_message();
+    virtual void release();
+
+private:
+    InputsChannel& _channel;
+};
+
+PositionMessage::PositionMessage(InputsChannel& channel)
+    : RedChannel::OutMessage()
+    , RedPeer::OutMessage(REDC_INPUTS_MOUSE_POSITION, sizeof(RedcMousePosition))
+    , _channel (channel)
+{
+}
+
+void PositionMessage::release()
+{
+    delete this;
+}
+
+RedPeer::OutMessage& PositionMessage::peer_message()
+{
+    _channel.set_position_event(*(RedcMousePosition*)data());
+    return *this;
+}
+
+class InputsMessHandler: public MessageHandlerImp<InputsChannel, RED_INPUTS_MESSAGES_END> {
+public:
+    InputsMessHandler(InputsChannel& channel)
+        : MessageHandlerImp<InputsChannel, RED_INPUTS_MESSAGES_END>(channel) {}
+};
+
+InputsChannel::InputsChannel(RedClient& client, uint32_t id)
+    : RedChannel(client, RED_CHANNEL_INPUTS, id, new InputsMessHandler(*this))
+    , _mouse_buttons_state (0)
+    , _mouse_dx (0)
+    , _mouse_dy (0)
+    , _mouse_x (~0)
+    , _mouse_y (~0)
+    , _display_id (-1)
+    , _active_motion (false)
+    , _motion_count (0)
+    , _active_modifiers_event (false)
+{
+    InputsMessHandler* handler = static_cast<InputsMessHandler*>(get_message_handler());
+    handler->set_handler(RED_MIGRATE, &InputsChannel::handle_migrate, 0);
+    handler->set_handler(RED_SET_ACK, &InputsChannel::handle_set_ack, sizeof(RedSetAck));
+    handler->set_handler(RED_PING, &InputsChannel::handle_ping, sizeof(RedPing));
+    handler->set_handler(RED_WAIT_FOR_CHANNELS, &InputsChannel::handle_wait_for_channels,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISCONNECTING, &InputsChannel::handle_disconnect,
+                         sizeof(RedDisconnect));
+    handler->set_handler(RED_NOTIFY, &InputsChannel::handle_notify, sizeof(RedNotify));
+
+    handler->set_handler(RED_INPUTS_INIT, &InputsChannel::handle_init, sizeof(RedInputsInit));
+    handler->set_handler(RED_INPUTS_KEY_MODIFAIERS, &InputsChannel::handle_modifaiers,
+                         sizeof(RedKeyModifiers));
+    handler->set_handler(RED_INPUTS_MOUSE_MOTION_ACK, &InputsChannel::handle_motion_ack, 0);
+}
+
+InputsChannel::~InputsChannel()
+{
+}
+
+void InputsChannel::on_connect()
+{
+    _motion_count = _mouse_dx = _mouse_dy = _mouse_buttons_state = _modifiers = 0;
+    _mouse_x = _mouse_y = ~0;
+    _display_id = -1;
+}
+
+void InputsChannel::on_disconnect()
+{
+    AutoRef<RemoveInputsHandlerEvent> remove_handler_event(new RemoveInputsHandlerEvent(*this));
+    get_client().push_event(*remove_handler_event);
+    (*remove_handler_event)->wait();
+}
+
+void InputsChannel::handle_init(RedPeer::InMessage* message)
+{
+    RedInputsInit* init = (RedInputsInit*)message->data();
+    _modifiers = init->keyboard_modifiers;
+    AutoRef<SetInputsHandlerEvent> set_handler_event(new SetInputsHandlerEvent(*this));
+    get_client().push_event(*set_handler_event);
+}
+
+void InputsChannel::handle_modifaiers(RedPeer::InMessage* message)
+{
+    RedKeyModifiers* init = (RedKeyModifiers*)message->data();
+    _modifiers = init->modifiers;
+    Lock lock(_update_modifiers_lock);
+    if (_active_modifiers_event) {
+        return;
+    }
+    _active_modifiers_event = true;
+    AutoRef<KeyModifiersEvent> modifiers_event(new KeyModifiersEvent(*this));
+    get_client().push_event(*modifiers_event);
+}
+
+void InputsChannel::handle_motion_ack(RedPeer::InMessage* message)
+{
+    Lock lock(_motion_lock);
+    if (_motion_count < RED_MOTION_ACK_BUNCH) {
+        LOG_WARN("invalid motion count");
+        _motion_count = 0;
+    } else {
+        _motion_count -= RED_MOTION_ACK_BUNCH;
+    }
+    if (!_active_motion && (_mouse_dx || _mouse_dy || _display_id != -1)) {
+        _active_motion = true;
+        _motion_count++;
+        switch (get_client().get_mouse_mode()) {
+        case RED_MOUSE_MODE_CLIENT:
+            post_message(new PositionMessage(*this));
+            break;
+        case RED_MOUSE_MODE_SERVER:
+            post_message(new MotionMessage(*this));
+            break;
+        default:
+            THROW("invalid mouse mode");
+        }
+    }
+}
+
+void InputsChannel::set_motion_event(RedcMouseMotion& motion)
+{
+    Lock lock(_motion_lock);
+    motion.buttons_state = _mouse_buttons_state;
+    motion.dx = _mouse_dx;
+    motion.dy = _mouse_dy;
+    _mouse_dx = _mouse_dy = 0;
+    _active_motion = false;
+}
+
+void InputsChannel::set_position_event(RedcMousePosition& position)
+{
+    Lock lock(_motion_lock);
+    position.buttons_state = _mouse_buttons_state;
+    position.x = _mouse_x;
+    position.y = _mouse_y;
+    position.display_id = _display_id;
+    _mouse_x = _mouse_y = ~0;
+    _display_id = -1;
+    _active_motion = false;
+}
+
+void InputsChannel::on_mouse_motion(int dx, int dy, int buttons_state)
+{
+    Lock lock(_motion_lock);
+    _mouse_buttons_state = buttons_state;
+    _mouse_dx += dx;
+    _mouse_dy += dy;
+    if (!_active_motion && _motion_count < RED_MOTION_ACK_BUNCH * 2) {
+        _active_motion = true;
+        _motion_count++;
+        post_message(new MotionMessage(*this));
+    }
+}
+
+void InputsChannel::on_mouse_position(int x, int y, int buttons_state, int display_id)
+{
+    Lock lock(_motion_lock);
+    _mouse_buttons_state = buttons_state;
+    _mouse_x = x;
+    _mouse_y = y;
+    _display_id = display_id;
+    if (!_active_motion && _motion_count < RED_MOTION_ACK_BUNCH * 2) {
+        _active_motion = true;
+        _motion_count++;
+        post_message(new PositionMessage(*this));
+    }
+}
+
+void InputsChannel::on_migrate()
+{
+    _motion_count = _active_motion ? 1 : 0;
+}
+
+void InputsChannel::on_mouse_down(int button, int buttons_state)
+{
+    Message* message;
+
+    message = new Message(REDC_INPUTS_MOUSE_PRESS, sizeof(RedcMouseRelease));
+    RedcMousePress* event = (RedcMousePress*)message->data();
+    event->button = button;
+    event->buttons_state = buttons_state;
+    post_message(message);
+}
+
+void InputsChannel::on_mouse_up(int button, int buttons_state)
+{
+    Message* message;
+
+    message = new Message(REDC_INPUTS_MOUSE_RELEASE, sizeof(RedcMouseRelease));
+    RedcMouseRelease* event = (RedcMouseRelease*)message->data();
+    event->button = button;
+    event->buttons_state = buttons_state;
+    post_message(message);
+}
+
+void InputsChannel::on_key_down(uint32_t scan_code)
+{
+    Message* message = new Message(REDC_INPUTS_KEY_DOWN, sizeof(RedcKeyDown));
+    RedcKeyDown* event = (RedcKeyDown*)message->data();
+    event->code = scan_code;
+    post_message(message);
+}
+
+void InputsChannel::on_key_up(uint32_t scan_code)
+{
+    Message* message = new Message(REDC_INPUTS_KEY_UP, sizeof(RedcKeyUp));
+    RedcKeyUp* event = (RedcKeyUp*)message->data();
+    event->code = scan_code;
+    post_message(message);
+}
+
+void InputsChannel::set_local_modifiers()
+{
+    unsigned int modifiers = 0;
+
+    if (_modifiers & RED_SCROLL_LOCK_MODIFIER) {
+        modifiers |= Platform::SCROLL_LOCK_MODIFIER;
+    }
+
+    if (_modifiers & RED_NUM_LOCK_MODIFIER) {
+        modifiers |= Platform::NUM_LOCK_MODIFIER;
+    }
+
+    if (_modifiers & RED_CAPS_LOCK_MODIFIER) {
+        modifiers |= Platform::CAPS_LOCK_MODIFIER;
+    }
+
+    Platform::set_keyboard_modifiers(_modifiers);
+}
+
+void InputsChannel::on_focus_in()
+{
+#ifdef SYNC_REMOTH_MODIFIRES
+    Message* message = new Message(REDC_INPUTS_KEY_MODIFAIERS, sizeof(RedcKeyDown));
+    RedcKeyModifiers* modifiers = (RedcKeyModifiers*)message->data();
+    modifiers->modifiers = Platform::get_keyboard_modifiers();
+    post_message(message);
+#else
+    set_local_modifiers();
+#endif
+}
+
+class InputsFactory: public ChannelFactory {
+public:
+    InputsFactory() : ChannelFactory(RED_CHANNEL_INPUTS) {}
+    virtual RedChannel* construct(RedClient& client, uint32_t id)
+    {
+        return new InputsChannel(client, id);
+    }
+};
+
+static InputsFactory factory;
+
+ChannelFactory& InputsChannel::Factory()
+{
+    return factory;
+}
+
diff --git a/client/inputs_channel.h b/client/inputs_channel.h
new file mode 100644
index 00000000..25341e18
--- /dev/null
+++ b/client/inputs_channel.h
@@ -0,0 +1,76 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_INPUTS_CHANNEL
+#define _H_INPUTS_CHANNEL
+
+#include "red_channel.h"
+#include "inputs_handler.h"
+
+class ChannelFactory;
+
+class InputsChannel: public RedChannel, public InputsHandler {
+public:
+    InputsChannel(RedClient& client, uint32_t id);
+    virtual ~InputsChannel();
+
+    virtual void on_mouse_motion(int dx, int dy, int buttons_state);
+    virtual void on_mouse_position(int x, int y, int buttons_state, int display_id);
+    virtual void on_mouse_down(int button, int buttons_state);
+    virtual void on_mouse_up(int button, int buttons_state);
+    virtual void on_key_down(uint32_t scan_code);
+    virtual void on_key_up(uint32_t scan_code);
+    virtual void on_focus_in();
+
+    static ChannelFactory& Factory();
+
+protected:
+    virtual void on_connect();
+    virtual void on_disconnect();
+    virtual void on_migrate();
+
+private:
+    void set_motion_event(RedcMouseMotion& motion_event);
+    void set_position_event(RedcMousePosition& position_event);
+    void set_local_modifiers();
+
+    void handle_init(RedPeer::InMessage* message);
+    void handle_modifaiers(RedPeer::InMessage* message);
+    void handle_motion_ack(RedPeer::InMessage* message);
+
+private:
+    Mutex _motion_lock;
+    int _mouse_buttons_state;
+    int _mouse_dx;
+    int _mouse_dy;
+    unsigned int _mouse_x;
+    unsigned int _mouse_y;
+    int _display_id;
+    bool _active_motion;
+    int _motion_count;
+    uint32_t _modifiers;
+    Mutex _update_modifiers_lock;
+    bool _active_modifiers_event;
+
+    friend class MotionMessage;
+    friend class PositionMessage;
+    friend class KeyModifiersEvent;
+};
+
+
+#endif
+
diff --git a/client/inputs_handler.h b/client/inputs_handler.h
new file mode 100644
index 00000000..3fd557e4
--- /dev/null
+++ b/client/inputs_handler.h
@@ -0,0 +1,36 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_INPUTS_HANDLER
+#define _H_INPUTS_HANDLER
+
+
+class InputsHandler {
+public:
+    virtual ~InputsHandler() {}
+    virtual void on_mouse_motion(int dx, int dy, int buttons_state) {}
+    virtual void on_mouse_position(int x, int y, int buttons_state, int display_id) {}
+    virtual void on_mouse_down(int button, int buttons_state) {}
+    virtual void on_mouse_up(int button, int buttons_state) {}
+    virtual void on_key_down(uint32_t scan_code) {}
+    virtual void on_key_up(uint32_t scan_code) {}
+    virtual void on_focus_in() {}
+    virtual void on_focus_out() {}
+};
+
+#endif
+
diff --git a/client/lz.cpp b/client/lz.cpp
new file mode 100644
index 00000000..9f104dfb
--- /dev/null
+++ b/client/lz.cpp
@@ -0,0 +1,20 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "../common/lz.c"
+
diff --git a/client/menu.cpp b/client/menu.cpp
new file mode 100644
index 00000000..343818c2
--- /dev/null
+++ b/client/menu.cpp
@@ -0,0 +1,100 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "menu.h"
+#include "utils.h"
+#include "debug.h"
+
+
+Menu::Menu(CommandTarget& target, const std::string& name)
+    : _refs (1)
+    , _target (target)
+    , _name (name)
+{
+}
+
+Menu::~Menu()
+{
+    for (unsigned int i = 0; i < _items.size(); i++) {
+        if (_items[i].type == MENU_ITEM_TYPE_COMMAND) {
+            delete (MenuCommand*)_items[i].obj;
+        } else if (_items[i].type == MENU_ITEM_TYPE_MENU) {
+            ((Menu*)_items[i].obj)->unref();
+        }
+    }
+}
+
+void Menu::add_item(MenuItem& item)
+{
+    int pos = _items.size();
+    _items.resize(pos + 1);
+    _items[pos] = item;
+}
+
+void Menu::add_command(const std::string& name, int cmd_id)
+{
+    MenuCommand* cmd = new MenuCommand(name, cmd_id);
+    MenuItem item;
+    item.type = MENU_ITEM_TYPE_COMMAND;
+    item.obj = cmd;
+    add_item(item);
+}
+
+void Menu::add_separator()
+{
+    MenuItem item;
+    item.type = MENU_ITEM_TYPE_SEPARATOR;
+    item.obj = NULL;
+    add_item(item);
+}
+
+void Menu::add_sub(Menu* menu)
+{
+    ASSERT(menu);
+    MenuItem item;
+    item.type = MENU_ITEM_TYPE_MENU;
+    item.obj = menu->ref();
+    add_item(item);
+}
+
+Menu::ItemType Menu::item_type_at(int pos)
+{
+    if (pos >= (int)_items.size()) {
+        return MENU_ITEM_TYPE_INVALID;
+    }
+    return _items[pos].type;
+}
+
+void Menu::command_at(int pos, std::string& name, int& cmd_id)
+{
+    if (_items[pos].type != MENU_ITEM_TYPE_COMMAND) {
+        THROW("incorrect item type");
+    }
+    MenuCommand* cmd = (MenuCommand*)_items[pos].obj;
+    name = cmd->get_name();
+    cmd_id = cmd->get_cmd_id();
+}
+
+Menu* Menu::sub_at(int pos)
+{
+    if (_items[pos].type != MENU_ITEM_TYPE_MENU) {
+        THROW("incorrect item type");
+    }
+    return ((Menu*)_items[pos].obj)->ref();
+}
+
diff --git a/client/menu.h b/client/menu.h
new file mode 100644
index 00000000..b908e549
--- /dev/null
+++ b/client/menu.h
@@ -0,0 +1,86 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_MENU
+#define _H_MENU
+
+class CommandTarget {
+public:
+    virtual void do_command(int command) = 0;
+    virtual ~CommandTarget() {}
+};
+
+class Menu {
+public:
+    Menu(CommandTarget& target, const std::string& name);
+
+    enum ItemType {
+        MENU_ITEM_TYPE_INVALID,
+        MENU_ITEM_TYPE_COMMAND,
+        MENU_ITEM_TYPE_MENU,
+        MENU_ITEM_TYPE_SEPARATOR,
+    };
+
+    Menu* ref() { _refs++; return this;}
+    void unref() { if (!--_refs) delete this;}
+
+    const std::string& get_name() { return _name;}
+    CommandTarget& get_target() { return _target;}
+
+    void add_command(const std::string& name, int cmd_id);
+    void add_separator();
+    void add_sub(Menu* sub);
+
+    ItemType item_type_at(int pos);
+    void command_at(int pos, std::string& name, int& cmd_id);
+    Menu* sub_at(int pos);
+
+private:
+    virtual ~Menu();
+
+    class MenuCommand {
+    public:
+        MenuCommand(const std::string& name, int cmd_id)
+            : _name (name)
+            , _cmd_id (cmd_id)
+        {
+        }
+
+        const std::string& get_name() { return _name;}
+        int get_cmd_id() { return _cmd_id;}
+
+    private:
+        std::string _name;
+        int _cmd_id;
+    };
+
+    struct MenuItem {
+        ItemType type;
+        void *obj;
+    };
+
+    void add_item(MenuItem& item);
+
+private:
+    int _refs;
+    CommandTarget& _target;
+    std::string _name;
+    std::vector<MenuItem> _items;
+};
+
+#endif
+
diff --git a/client/monitor.cpp b/client/monitor.cpp
new file mode 100644
index 00000000..85267693
--- /dev/null
+++ b/client/monitor.cpp
@@ -0,0 +1,35 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "monitor.h"
+#include "debug.h"
+
+uint32_t Monitor::self_monitors_change = 0;
+
+
+Monitor::Monitor(int id)
+    : _id (id)
+    , _free (true)
+{
+}
+
+bool Monitor::is_self_change()
+{
+    return self_monitors_change != 0;
+}
+
diff --git a/client/monitor.h b/client/monitor.h
new file mode 100644
index 00000000..59ec1e06
--- /dev/null
+++ b/client/monitor.h
@@ -0,0 +1,56 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_MONITOR
+#define _H_MONITOR
+
+#include "draw.h"
+
+class Monitor {
+public:
+    Monitor(int id);
+
+    int get_id() { return _id;}
+    bool is_free() { return _free;}
+    void set_free() {_free = true;}
+    void set_used() {_free = false;}
+
+    virtual void set_mode(int width, int height) = 0;
+    virtual void restore() = 0;
+    virtual int get_depth() = 0;
+    virtual Point get_position() = 0;
+    virtual Point get_size() const = 0;
+    virtual bool is_out_of_sync() = 0;
+    virtual int get_screen_id() = 0;
+
+    static bool is_self_change();
+
+protected:
+    virtual ~Monitor() {}
+
+private:
+    int _id;
+    bool _free;
+
+protected:
+    static uint32_t self_monitors_change;
+
+    friend class Platform;
+};
+
+#endif
+
diff --git a/client/pixels_source.h b/client/pixels_source.h
new file mode 100644
index 00000000..2fe09eab
--- /dev/null
+++ b/client/pixels_source.h
@@ -0,0 +1,59 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PIXELS_SOURCE
+#define _H_PIXELS_SOURCE
+
+#include "draw.h"
+
+#define PIXELES_SOURCE_OPAQUE_SIZE (20 * sizeof(void*))
+
+class PixelsSource {
+public:
+    PixelsSource();
+    virtual ~PixelsSource();
+
+    virtual Point get_size() = 0;
+    void set_origin(int x, int y) { _origin.x = x; _origin.y = y;}
+    const Point& get_origin() { return _origin;}
+
+protected:
+    const uint8_t* get_opaque() const { return _opaque;}
+
+private:
+    Point _origin;
+    uint8_t _opaque[PIXELES_SOURCE_OPAQUE_SIZE];
+
+    friend class RedDrawable;
+};
+
+class ImageFromRes: public PixelsSource {
+public:
+    ImageFromRes(int res_id);
+    virtual ~ImageFromRes();
+    virtual Point get_size();
+};
+
+class AlphaImageFromRes: public PixelsSource {
+public:
+    AlphaImageFromRes(int res_id);
+    virtual ~AlphaImageFromRes();
+    virtual Point get_size();
+};
+
+#endif
+
diff --git a/client/platform.h b/client/platform.h
new file mode 100644
index 00000000..0982bf63
--- /dev/null
+++ b/client/platform.h
@@ -0,0 +1,158 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PLATFORM
+#define _H_PLATFORM
+
+#include "cursor.h"
+#include "events_loop.h"
+
+#define INVALID_TIMER (~TimerID(0))
+typedef unsigned long TimerID;
+typedef void (*timer_proc_t)(void* opaque, TimerID timer);
+
+class WaveRecordAbstract;
+class WavePlaybackAbstract;
+class Icon;
+
+class Monitor;
+typedef std::list<Monitor*> MonitorsList;
+
+class Platform {
+public:
+    static void init();
+    static void wait_events();
+    static bool process_events();
+    static void wakeup();
+    static void msleep(unsigned int millisec);
+    static void yield();
+    static void send_quit_request();
+    static TimerID create_interval_timer(timer_proc_t proc, void* opaque);
+    static bool activate_interval_timer(TimerID timer, unsigned int millisec);
+    static bool deactivate_interval_timer(TimerID timer);
+    static void destroy_interval_timer(TimerID timer);
+    static uint64_t get_monolithic_time();
+    static void get_temp_dir(std::string& path);
+
+    static const MonitorsList& init_monitors();
+    static void destroy_monitors();
+    static bool is_monitors_pos_valid();
+
+    enum ThreadPriority {
+        PRIORITY_INVALID,
+        PRIORITY_TIME_CRITICAL,
+        PRIORITY_HIGH,
+        PRIORITY_ABOVE_NORMAL,
+        PRIORITY_NORMAL,
+        PRIORITY_BELOW_NORMAL,
+        PRIORITY_LOW,
+        PRIORITY_IDLE,
+    };
+
+    static void set_thread_priority(void *thread, ThreadPriority priority);
+
+    class RecordClinet;
+    static WaveRecordAbstract* create_recorder(RecordClinet& client,
+                                               uint32_t sampels_per_sec,
+                                               uint32_t bits_per_sample,
+                                               uint32_t channels);
+    static WavePlaybackAbstract* create_player(uint32_t sampels_per_sec,
+                                               uint32_t bits_per_sample,
+                                               uint32_t channels);
+
+    enum {
+        SCROLL_LOCK_MODIFIER_SHIFT,
+        NUM_LOCK_MODIFIER_SHIFT,
+        CAPS_LOCK_MODIFIER_SHIFT,
+
+        SCROLL_LOCK_MODIFIER = (1 << SCROLL_LOCK_MODIFIER_SHIFT),
+        NUM_LOCK_MODIFIER = (1 << NUM_LOCK_MODIFIER_SHIFT),
+        CAPS_LOCK_MODIFIER = (1 << CAPS_LOCK_MODIFIER_SHIFT),
+    };
+
+    static uint32_t get_keyboard_modifiers();
+    static void set_keyboard_modifiers(uint32_t modifiers);
+
+    static LocalCursor* create_local_cursor(CursorData* cursor_data);
+    static LocalCursor* create_inactive_cursor();
+    static LocalCursor* create_default_cursor();
+
+    static Icon* load_icon(int id);
+
+    class EventListener;
+    static void set_event_listener(EventListener* listener);
+
+    class DisplayModeListner;
+    static void set_display_mode_listner(DisplayModeListner* listener);
+};
+
+class Platform::EventListener {
+public:
+    virtual ~EventListener() {}
+    virtual void on_app_activated() = 0;
+    virtual void on_app_deactivated() = 0;
+    virtual void on_monitors_change() = 0;
+};
+
+class Platform::RecordClinet {
+public:
+    virtual ~RecordClinet() {}
+    virtual void add_evnet_sorce(EventsLoop::File& evnet_sorce) = 0;
+    virtual void remove_evnet_sorce(EventsLoop::File& evnet_sorce) = 0;
+    virtual void add_evnet_sorce(EventsLoop::Trigger& evnet_sorce) = 0;
+    virtual void remove_evnet_sorce(EventsLoop::Trigger& evnet_sorce) = 0;
+    virtual void push_frame(uint8_t *frame) = 0;
+};
+
+class Platform::DisplayModeListner {
+public:
+    virtual ~DisplayModeListner() {}
+    virtual void on_display_mode_change() = 0;
+};
+
+class NamedPipe {
+public:
+    typedef unsigned long ListenerRef;
+    typedef unsigned long ConnectionRef;
+    static const ConnectionRef INVALID_CONNECTION = ~0;
+
+    class ConnectionInterface {
+    public:
+        ConnectionInterface() : _opaque (INVALID_CONNECTION) {}
+        virtual ~ConnectionInterface() {}
+        virtual void bind(ConnectionRef conn_ref) = 0;
+        virtual void on_data() = 0;
+
+    protected:
+        ConnectionRef _opaque;
+    };
+
+    class ListenerInterface {
+    public:
+        virtual ~ListenerInterface() {}
+        virtual ConnectionInterface &create() = 0;
+    };
+
+    static ListenerRef create(const char *name, ListenerInterface& listener_interface);
+    static void destroy(ListenerRef listener_ref);
+    static void destroy_connection(ConnectionRef conn_ref);
+    static int32_t read(ConnectionRef conn_ref, uint8_t *buf, int32_t size);
+    static int32_t write(ConnectionRef conn_ref, const uint8_t *buf, int32_t size);
+};
+
+#endif
+
diff --git a/client/playback_channel.cpp b/client/playback_channel.cpp
new file mode 100644
index 00000000..fd20b0ac
--- /dev/null
+++ b/client/playback_channel.cpp
@@ -0,0 +1,355 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_client.h"
+#include "audio_channels.h"
+#include "audio_devices.h"
+
+//#define WAVE_CAPTURE
+#ifdef WAVE_CAPTURE
+
+#include <fcntl.h>
+
+#define WAVE_BUF_SIZE (1024 * 1024 * 20)
+
+typedef struct __attribute__ ((__packed__)) ChunkHeader {
+    uint32_t id;
+    uint32_t size;
+} ChunkHeader;
+
+typedef struct __attribute__ ((__packed__)) FormatInfo {
+    uint16_t compression_code;
+    uint16_t num_channels;
+    uint32_t sample_rate;
+    uint32_t average_bytes_per_second;
+    uint16_t block_align;
+    uint16_t bits_per_sample;
+    //uint16_t extra_format_bytes;
+    //uint8_t extra[0];
+} FormatInfo;
+
+static uint8_t* wave_buf = NULL;
+static uint8_t* wave_now = NULL;
+static uint8_t* wave_end = NULL;
+static bool wave_blocked = false;
+
+static void write_all(int fd, uint8_t* data, uint32_t size)
+{
+    while (size) {
+        int n = write(fd, data, size);
+        if (n == -1) {
+            if (errno != EINTR) {
+                throw Exception(fmt("%s: failed") % __FUNCTION__);
+            }
+        } else {
+            data += n;
+            size -= n;
+        }
+    }
+}
+
+static void write_wave()
+{
+    static uint32_t file_id = 0;
+    char file_name[100];
+    ChunkHeader header;
+    FormatInfo format;
+
+    if (wave_buf == wave_now) {
+        return;
+    }
+
+    sprintf(file_name, "/tmp/%u.wav", ++file_id);
+    int fd = open(file_name, O_CREAT | O_TRUNC | O_WRONLY, 0644);
+    if (fd == -1) {
+        DBG(0, fmt("open file %s failed") % file_name);
+        return;
+    }
+
+    memcpy((char *)&header.id, "RIFF", 4);
+    header.size = 4;
+    write_all(fd, (uint8_t *)&header, sizeof(header));
+    write_all(fd, (uint8_t *)"WAVE", 4);
+
+    memcpy((char *)&header.id, "fmt ", 4);
+    header.size = sizeof(format);
+    write_all(fd, (uint8_t *)&header, sizeof(header));
+
+    format.compression_code = 1;
+    format.num_channels = 2;
+    format.sample_rate = 44100;
+    format.average_bytes_per_second = format.sample_rate * 4;
+    format.block_align = 4;
+    format.bits_per_sample = 16;
+    write_all(fd, (uint8_t *)&format, sizeof(format));
+
+    memcpy((char *)&header.id, "data", 4);
+    header.size = wave_now - wave_buf;
+    write_all(fd, (uint8_t *)&header, sizeof(header));
+    write_all(fd, wave_buf, header.size);
+    close(fd);
+}
+
+static void init_wave()
+{
+    if (!wave_buf) {
+        wave_buf = new uint8_t[WAVE_BUF_SIZE];
+    }
+    wave_now = wave_buf;
+    wave_end = wave_buf + WAVE_BUF_SIZE;
+}
+
+static void start_wave()
+{
+    wave_blocked = false;
+    wave_now = wave_buf;
+}
+
+static void put_wave_data(uint8_t *data, uint32_t size)
+{
+    if (wave_blocked || size > wave_end - wave_now) {
+        wave_blocked = true;
+        return;
+    }
+    memcpy((void *)wave_now, (void *)data, size);
+    wave_now += size;
+}
+
+static void end_wave()
+{
+    write_wave();
+}
+
+#endif
+
+class PlaybackHandler: public MessageHandlerImp<PlaybackChannel, RED_PLAYBACK_MESSAGES_END> {
+public:
+    PlaybackHandler(PlaybackChannel& channel)
+        : MessageHandlerImp<PlaybackChannel, RED_PLAYBACK_MESSAGES_END>(channel) {}
+};
+
+PlaybackChannel::PlaybackChannel(RedClient& client, uint32_t id)
+    : RedChannel(client, RED_CHANNEL_PLAYBACK, id, new PlaybackHandler(*this),
+                 Platform::PRIORITY_HIGH)
+    , _wave_player (NULL)
+    , _mode (RED_AUDIO_DATA_MODE_INVALD)
+    , _celt_mode (NULL)
+    , _celt_decoder (NULL)
+    , _playing (false)
+{
+#ifdef WAVE_CAPTURE
+    init_wave();
+#endif
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+
+    handler->set_handler(RED_MIGRATE, &PlaybackChannel::handle_migrate, 0);
+    handler->set_handler(RED_SET_ACK, &PlaybackChannel::handle_set_ack, sizeof(RedSetAck));
+    handler->set_handler(RED_PING, &PlaybackChannel::handle_ping, sizeof(RedPing));
+    handler->set_handler(RED_WAIT_FOR_CHANNELS, &PlaybackChannel::handle_wait_for_channels,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISCONNECTING, &PlaybackChannel::handle_disconnect,
+                         sizeof(RedDisconnect));
+    handler->set_handler(RED_NOTIFY, &PlaybackChannel::handle_notify, sizeof(RedNotify));
+
+    handler->set_handler(RED_PLAYBACK_MODE, &PlaybackChannel::handle_mode,
+                         sizeof(RedPlaybackMode));
+
+    set_capability(RED_PLAYBACK_CAP_CELT_0_5_1);
+}
+
+PlaybackChannel::~PlaybackChannel(void)
+{
+    delete _wave_player;
+
+    if (_celt_decoder) {
+        celt051_decoder_destroy(_celt_decoder);
+    }
+
+    if (_celt_mode) {
+        celt051_mode_destroy(_celt_mode);
+    }
+}
+
+bool PlaybackChannel::abort(void)
+{
+    return (!_wave_player || _wave_player->abort()) && RedChannel::abort();
+}
+
+void PlaybackChannel::set_data_handler()
+{
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+
+    if (_mode == RED_AUDIO_DATA_MODE_RAW) {
+        handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::handle_raw_data, 0);
+    } else if (_mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+        handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::handle_celt_data, 0);
+    } else {
+        THROW("invalid mode");
+    }
+}
+
+void PlaybackChannel::handle_mode(RedPeer::InMessage* message)
+{
+    RedPlaybackMode* playbacke_mode = (RedPlaybackMode*)message->data();
+    if (playbacke_mode->mode != RED_AUDIO_DATA_MODE_RAW &&
+        playbacke_mode->mode != RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+        THROW("invalid mode");
+    }
+
+    _mode = playbacke_mode->mode;
+    if (_playing) {
+        set_data_handler();
+        return;
+    }
+
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::handle_start,
+                         sizeof(RedPlaybackStart));
+}
+
+void PlaybackChannel::null_handler(RedPeer::InMessage* message)
+{
+}
+
+void PlaybackChannel::disable()
+{
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+
+    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(RED_PLAYBACK_STOP, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(RED_PLAYBACK_MODE, &PlaybackChannel::null_handler, 0);
+    handler->set_handler(RED_PLAYBACK_DATA, &PlaybackChannel::null_handler, 0);
+}
+
+void PlaybackChannel::handle_start(RedPeer::InMessage* message)
+{
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+    RedPlaybackStart* start = (RedPlaybackStart*)message->data();
+
+    handler->set_handler(RED_PLAYBACK_START, NULL, 0);
+    handler->set_handler(RED_PLAYBACK_STOP, &PlaybackChannel::handle_stop, 0);
+
+#ifdef WAVE_CAPTURE
+    start_wave();
+#endif
+    if (!_wave_player) {
+        // for now support only one setting
+        int celt_mode_err;
+
+        if (start->format != RED_AUDIO_FMT_S16) {
+            THROW("unexpected format");
+        }
+        int bits_per_sample = 16;
+        int frame_size = 256;
+        _frame_bytes = frame_size * start->channels * bits_per_sample / 8;
+        try {
+            _wave_player = Platform::create_player(start->frequency, bits_per_sample,
+                                                   start->channels);
+        } catch (...) {
+            LOG_WARN("create player failed");
+            //todo: support disconnecting singel channel
+            disable();
+            return;
+        }
+
+        if (!(_celt_mode = celt051_mode_create(start->frequency, start->channels,
+                                               frame_size, &celt_mode_err))) {
+            THROW("create celt mode failed %d", celt_mode_err);
+        }
+
+        if (!(_celt_decoder = celt051_decoder_create(_celt_mode))) {
+            THROW("create celt decoder");
+        }
+    }
+    _playing = true;
+    _frame_count = 0;
+    set_data_handler();
+}
+
+void PlaybackChannel::handle_stop(RedPeer::InMessage* message)
+{
+    PlaybackHandler* handler = static_cast<PlaybackHandler*>(get_message_handler());
+
+    handler->set_handler(RED_PLAYBACK_STOP, NULL, 0);
+    handler->set_handler(RED_PLAYBACK_DATA, NULL, 0);
+    handler->set_handler(RED_PLAYBACK_START, &PlaybackChannel::handle_start,
+                         sizeof(RedPlaybackStart));
+
+#ifdef WAVE_CAPTURE
+    end_wave();
+#endif
+    _wave_player->stop();
+    _playing = false;
+}
+
+void PlaybackChannel::handle_raw_data(RedPeer::InMessage* message)
+{
+    RedPlaybackPacket* packet = (RedPlaybackPacket*)message->data();
+    uint8_t* data = (uint8_t*)(packet + 1);
+    uint32_t size = message->size() - sizeof(*packet);
+#ifdef WAVE_CAPTURE
+    put_wave_data(data, size);
+    return;
+#endif
+    if (size != _frame_bytes) {
+        //for now throw on unexpected size (based on current server imp).
+        // will probably be replaced by supporting flexible data size in the player imp
+        THROW("unexpected frame size");
+    }
+    if ((_frame_count++ % 1000) == 0) {
+        get_client().set_mm_time(packet->time - _wave_player->get_delay_ms());
+    }
+    _wave_player->write(data);
+}
+
+void PlaybackChannel::handle_celt_data(RedPeer::InMessage* message)
+{
+    RedPlaybackPacket* packet = (RedPlaybackPacket*)message->data();
+    uint8_t* data = (uint8_t*)(packet + 1);
+    uint32_t size = message->size() - sizeof(*packet);
+    celt_int16_t pcm[256 * 2];
+
+    if (celt051_decode(_celt_decoder, data, size, pcm) != CELT_OK) {
+        THROW("celt decode failed");
+    }
+#ifdef WAVE_CAPTURE
+    put_wave_data(pcm, _frame_bytes);
+    return;
+#endif
+    if ((_frame_count++ % 1000) == 0) {
+        get_client().set_mm_time(packet->time - _wave_player->get_delay_ms());
+    }
+    _wave_player->write((uint8_t *)pcm);
+}
+
+class PlaybackFactory: public ChannelFactory {
+public:
+    PlaybackFactory() : ChannelFactory(RED_CHANNEL_PLAYBACK) {}
+    virtual RedChannel* construct(RedClient& client, uint32_t id)
+    {
+        return new PlaybackChannel(client, id);
+    }
+};
+
+static PlaybackFactory factory;
+
+ChannelFactory& PlaybackChannel::Factory()
+{
+    return factory;
+}
+
diff --git a/client/quic.cpp b/client/quic.cpp
new file mode 100644
index 00000000..f992e50d
--- /dev/null
+++ b/client/quic.cpp
@@ -0,0 +1,20 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "../common/quic.c"
+
diff --git a/client/read_write_mutex.h b/client/read_write_mutex.h
new file mode 100644
index 00000000..721422e5
--- /dev/null
+++ b/client/read_write_mutex.h
@@ -0,0 +1,120 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_READ_WRITE_MUTEX
+#define _H_READ_WRITE_MUTEX
+
+#include "threads.h"
+
+class ReadWriteMutex {
+public:
+    ReadWriteMutex()
+    {
+        _state.read_count = 0;
+        _state.write = false;
+        _state.write_waiting = false;
+    }
+
+    virtual ~ReadWriteMutex()
+    {
+    }
+
+    void read_lock()
+    {
+        Lock lock(_state_mutex);
+
+        while (_state.write || _state.write_waiting) {
+            _read_cond.wait(lock);
+        }
+
+        ++_state.read_count;
+    }
+
+    bool try_read_lock()
+    {
+        Lock lock(_state_mutex);
+        if (_state.write || _state.write_waiting) {
+            return false;
+        } else {
+            ++_state.read_count;
+            return true;
+        }
+    }
+
+    void read_unlock()
+    {
+        Lock lock(_state_mutex);
+        --_state.read_count;
+
+        if (!_state.read_count) { // last reader
+            _state.write_waiting = false;
+            release_waiters();
+        }
+    }
+
+    void write_lock()
+    {
+        Lock lock(_state_mutex);
+
+        while (_state.read_count || _state.write) {
+            _state.write_waiting = true;
+            _write_cond.wait(lock);
+        }
+        _state.write = true;
+    }
+
+    bool try_write_lock()
+    {
+        Lock lock(_state_mutex);
+
+        if (_state.read_count || _state.write) {
+            return false;
+        } else {
+            _state.write = true;
+            return true;
+        }
+    }
+
+    void write_unlock()
+    {
+        Lock lock(_state_mutex);
+        _state.write = false;
+        _state.write_waiting = false;
+        release_waiters();
+    }
+
+private:
+    void release_waiters()
+    {
+        _write_cond.notify_one();
+        _read_cond.notify_all();
+    }
+
+private:
+    struct {
+        unsigned int read_count;
+        bool write;
+        bool write_waiting;
+    } _state;
+
+    Mutex _state_mutex;
+    Condition _read_cond;
+    Condition _write_cond;
+};
+
+#endif
+
diff --git a/client/record_channel.cpp b/client/record_channel.cpp
new file mode 100644
index 00000000..5bba1dbb
--- /dev/null
+++ b/client/record_channel.cpp
@@ -0,0 +1,280 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_client.h"
+#include "audio_channels.h"
+#include "audio_devices.h"
+
+#define NUM_SAMPLES_MESSAGES 4
+
+
+static uint32_t get_mm_time()
+{
+    return uint32_t(Platform::get_monolithic_time() / (1000 * 1000));
+}
+
+class RecordSamplesMessage: public RedChannel::OutMessage {
+public:
+    RecordSamplesMessage(RecordChannel& channel);
+    virtual ~RecordSamplesMessage();
+
+    virtual RedPeer::OutMessage& peer_message() { return *_massage;}
+    virtual void release();
+
+private:
+    RecordChannel& _channel;
+    RedPeer::OutMessage *_massage;
+};
+
+RecordSamplesMessage::RecordSamplesMessage(RecordChannel& channel)
+    : _channel (channel)
+    , _massage (new Message(REDC_RECORD_DATA, sizeof(RedcRecordPacket) + 4096))
+{
+}
+
+RecordSamplesMessage::~RecordSamplesMessage()
+{
+    delete _massage;
+}
+
+void RecordSamplesMessage::release()
+{
+    _channel.release_message(this);
+}
+
+int RecordChannel::data_mode = RED_AUDIO_DATA_MODE_CELT_0_5_1;
+
+class RecordHandler: public MessageHandlerImp<RecordChannel, REDC_RECORD_MESSAGES_END> {
+public:
+    RecordHandler(RecordChannel& channel)
+        : MessageHandlerImp<RecordChannel, REDC_RECORD_MESSAGES_END>(channel) {}
+};
+
+RecordChannel::RecordChannel(RedClient& client, uint32_t id)
+    : RedChannel(client, RED_CHANNEL_RECORD, id, new RecordHandler(*this))
+    , _wave_recorder (NULL)
+    , _mode (RED_AUDIO_DATA_MODE_INVALD)
+    , _celt_mode (NULL)
+    , _celt_encoder (NULL)
+{
+    for (int i = 0; i < NUM_SAMPLES_MESSAGES; i++) {
+        _messages.push_front(new RecordSamplesMessage(*this));
+    }
+
+    RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
+
+    handler->set_handler(RED_MIGRATE, &RecordChannel::handle_migrate, 0);
+    handler->set_handler(RED_SET_ACK, &RecordChannel::handle_set_ack, sizeof(RedSetAck));
+    handler->set_handler(RED_PING, &RecordChannel::handle_ping, sizeof(RedPing));
+    handler->set_handler(RED_WAIT_FOR_CHANNELS, &RecordChannel::handle_wait_for_channels,
+                         sizeof(RedWaitForChannels));
+    handler->set_handler(RED_DISCONNECTING, &RecordChannel::handle_disconnect,
+                         sizeof(RedDisconnect));
+    handler->set_handler(RED_NOTIFY, &RecordChannel::handle_notify, sizeof(RedNotify));
+
+    handler->set_handler(RED_RECORD_START, &RecordChannel::handle_start, sizeof(RedRecordStart));
+
+    set_capability(RED_RECORD_CAP_CELT_0_5_1);
+}
+
+RecordChannel::~RecordChannel(void)
+{
+    while (!_messages.empty()) {
+        RecordSamplesMessage *mes;
+        mes = *_messages.begin();
+        _messages.pop_front();
+        delete mes;
+    }
+    delete _wave_recorder;
+
+    if (_celt_encoder) {
+        celt051_encoder_destroy(_celt_encoder);
+    }
+    if (_celt_mode) {
+        celt051_mode_destroy(_celt_mode);
+    }
+}
+
+bool RecordChannel::abort(void)
+{
+    return (!_wave_recorder || _wave_recorder->abort()) && RedChannel::abort();
+}
+
+void RecordChannel::on_connect()
+{
+    Message* message = new Message(REDC_RECORD_MODE, sizeof(RedcRecordMode));
+    RedcRecordMode *mode = (RedcRecordMode *)message->data();
+    mode->time = get_mm_time();
+    mode->mode = _mode = test_capability(RED_RECORD_CAP_CELT_0_5_1) ? RecordChannel::data_mode :
+                                                                      RED_AUDIO_DATA_MODE_RAW;
+    post_message(message);
+}
+
+void RecordChannel::send_start_mark()
+{
+    Message* message = new Message(REDC_RECORD_START_MARK, sizeof(RedcRecordStartMark));
+    RedcRecordStartMark *start_mark = (RedcRecordStartMark *)message->data();
+    start_mark->time = get_mm_time();
+    post_message(message);
+}
+
+void RecordChannel::handle_start(RedPeer::InMessage* message)
+{
+    RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
+    RedRecordStart* start = (RedRecordStart*)message->data();
+
+    handler->set_handler(RED_RECORD_START, NULL, 0);
+    handler->set_handler(RED_RECORD_STOP, &RecordChannel::handle_stop, 0);
+    ASSERT(!_wave_recorder && !_celt_mode && !_celt_encoder);
+
+    // for now support only one setting
+    if (start->format != RED_AUDIO_FMT_S16) {
+        THROW("unexpected format");
+    }
+
+    int bits_per_sample = 16;
+    try {
+        _wave_recorder = Platform::create_recorder(*this, start->frequency,
+                                                   bits_per_sample,
+                                                   start->channels);
+    } catch (...) {
+        LOG_WARN("create recorder failed");
+        return;
+    }
+
+    int frame_size = 256;
+    int celt_mode_err;
+    _frame_bytes = frame_size * bits_per_sample * start->channels / 8;
+    if (!(_celt_mode = celt051_mode_create(start->frequency, start->channels, frame_size,
+                                           &celt_mode_err))) {
+        THROW("create celt mode failed %d", celt_mode_err);
+    }
+
+    if (!(_celt_encoder = celt051_encoder_create(_celt_mode))) {
+        THROW("create celt encoder failed");
+    }
+
+    send_start_mark();
+    _wave_recorder->start();
+}
+
+void RecordChannel::handle_stop(RedPeer::InMessage* message)
+{
+    RecordHandler* handler = static_cast<RecordHandler*>(get_message_handler());
+    handler->set_handler(RED_RECORD_START, &RecordChannel::handle_start, sizeof(RedRecordStart));
+    handler->set_handler(RED_RECORD_STOP, NULL, 0);
+    if (!_wave_recorder) {
+        return;
+    }
+    ASSERT(_celt_mode && _celt_encoder);
+    _wave_recorder->stop();
+    celt051_encoder_destroy(_celt_encoder);
+    _celt_encoder = NULL;
+    celt051_mode_destroy(_celt_mode);
+    _celt_mode = NULL;
+    delete _wave_recorder;
+    _wave_recorder = NULL;
+}
+
+RecordSamplesMessage* RecordChannel::get_message()
+{
+    Lock lock(_messages_lock);
+    if (_messages.empty()) {
+        return NULL;
+    }
+
+    RecordSamplesMessage* ret = *_messages.begin();
+    _messages.pop_front();
+    return ret;
+}
+
+void RecordChannel::release_message(RecordSamplesMessage *message)
+{
+    Lock lock(_messages_lock);
+    _messages.push_front(message);
+}
+
+void RecordChannel::add_evnet_sorce(EventsLoop::File& evnet_sorce)
+{
+    get_events_loop().add_file(evnet_sorce);
+}
+
+void RecordChannel::remove_evnet_sorce(EventsLoop::File& evnet_sorce)
+{
+    get_events_loop().remove_file(evnet_sorce);
+}
+
+void RecordChannel::add_evnet_sorce(EventsLoop::Trigger& evnet_sorce)
+{
+    get_events_loop().add_trigger(evnet_sorce);
+}
+
+void RecordChannel::remove_evnet_sorce(EventsLoop::Trigger& evnet_sorce)
+{
+    get_events_loop().remove_trigger(evnet_sorce);
+}
+
+#define FRAME_SIZE 256
+#define CELT_BIT_RATE (64 * 1024)
+#define CELT_COMPRESSED_FRAME_BYTES (FRAME_SIZE * CELT_BIT_RATE / 44100 / 8)
+
+void RecordChannel::push_frame(uint8_t *frame)
+{
+    RecordSamplesMessage *message;
+    ASSERT(_frame_bytes == FRAME_SIZE * 4);
+    if (!(message = get_message())) {
+        DBG(0, "blocked");
+        return;
+    }
+    uint8_t celt_buf[CELT_COMPRESSED_FRAME_BYTES];
+    int n;
+
+    if (_mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+        n = celt051_encode(_celt_encoder, (celt_int16_t *)frame, NULL, celt_buf,
+                           CELT_COMPRESSED_FRAME_BYTES);
+        if (n < 0) {
+            THROW("celt encode failed");
+        }
+        frame = celt_buf;
+    } else {
+        n = _frame_bytes;
+    }
+    RedPeer::OutMessage& peer_message = message->peer_message();
+    peer_message.resize(n + sizeof(RedcRecordPacket));
+    RedcRecordPacket* packet = (RedcRecordPacket*)peer_message.data();
+    packet->time = get_mm_time();
+    memcpy(packet->data, frame, n);
+    post_message(message);
+}
+
+class RecordFactory: public ChannelFactory {
+public:
+    RecordFactory() : ChannelFactory(RED_CHANNEL_RECORD) {}
+    virtual RedChannel* construct(RedClient& client, uint32_t id)
+    {
+        return new RecordChannel(client, id);
+    }
+};
+
+static RecordFactory factory;
+
+ChannelFactory& RecordChannel::Factory()
+{
+    return factory;
+}
+
diff --git a/client/red_cairo_canvas.cpp b/client/red_cairo_canvas.cpp
new file mode 100644
index 00000000..02a48e4c
--- /dev/null
+++ b/client/red_cairo_canvas.cpp
@@ -0,0 +1,201 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <stdint.h>
+#include "red_window.h"
+#include "red_cairo_canvas.h"
+#include "utils.h"
+#include "debug.h"
+#include "region.h"
+#include "red_pixmap_cairo.h"
+
+CCanvas::CCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+                 GlzDecoderWindow &glz_decoder_window)
+    : Canvas (pixmap_cache, palette_cache, glz_decoder_window)
+    , _canvas (NULL)
+    , _pixmap (0)
+{
+}
+
+CCanvas::~CCanvas()
+{
+    destroy();
+}
+
+void CCanvas::destroy()
+{
+    if (_canvas) {
+        cairo_t *cairo = canvas_get_cairo(_canvas);
+        canvas_destroy(_canvas);
+        cairo_destroy(cairo);
+        _canvas = NULL;
+    }
+    destroy_pixmap();
+}
+
+void CCanvas::clear()
+{
+    if (_canvas) {
+        canvas_clear(_canvas);
+    }
+}
+
+void CCanvas::destroy_pixmap()
+{
+    delete _pixmap;
+    _pixmap = NULL;
+}
+
+void CCanvas::create_pixmap(int width, int height, RedWindow *win)
+{
+    _pixmap = new RedPixmapCairo(width, height, RedPixmap::RGB32, true, NULL, win);
+}
+
+void CCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
+{
+    for (int i = 0; i < (int)region.num_rects; i++) {
+        Rect* r = &region.rects[i];
+        dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
+    }
+}
+
+void CCanvas::copy_pixels(const QRegion& region, RedDrawable* dest_dc, const PixmapHeader* pixmap)
+{
+    copy_pixels(region, *dest_dc);
+}
+
+void CCanvas::set_mode(int width, int height, int depth, RedWindow *win)
+{
+    cairo_surface_t *cairo_surface;
+    cairo_t *cairo;
+
+    destroy();
+    create_pixmap(width, height, win);
+    cairo_surface = cairo_image_surface_create_for_data(_pixmap->get_data(), CAIRO_FORMAT_RGB24,
+                                                        width, height, _pixmap->get_stride());
+    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+        THROW("create surface failed, %s",
+              cairo_status_to_string(cairo_surface_status(cairo_surface)));
+    }
+
+    cairo = cairo_create(cairo_surface);
+    cairo_surface_destroy(cairo_surface);
+    if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
+        THROW("create cairo failed, %s", cairo_status_to_string(cairo_status(cairo)));
+    }
+    if (!(_canvas = canvas_create(cairo, depth,
+                                  &pixmap_cache(), bits_cache_put, bits_cache_get,
+                                  &palette_cache(), palette_cache_put, palette_cache_get,
+                                  palette_cache_release,
+                                  &glz_decoder(),
+                                  glz_decode))) {
+        THROW("create canvas failed");
+    }
+}
+
+void CCanvas::set_access_params(ADDRESS delta, unsigned long base, unsigned long max)
+{
+    canvas_set_access_params(_canvas, delta, base, max);
+}
+
+void CCanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+{
+    canvas_draw_fill(_canvas, bbox, clip, fill);
+}
+
+void CCanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+{
+    canvas_draw_text(_canvas, bbox, clip, text);
+}
+
+void CCanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    canvas_draw_opaque(_canvas, bbox, clip, opaque);
+}
+
+void CCanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+{
+    canvas_draw_copy(_canvas, bbox, clip, copy);
+}
+
+void CCanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+{
+    canvas_draw_transparent(_canvas, bbox, clip, transparent);
+}
+
+void CCanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+    canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
+}
+
+void CCanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+{
+    canvas_copy_bits(_canvas, bbox, clip, src_pos);
+}
+
+void CCanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+{
+    canvas_draw_blend(_canvas, bbox, clip, blend);
+}
+
+void CCanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    canvas_draw_blackness(_canvas, bbox, clip, blackness);
+}
+
+void CCanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
+}
+
+void CCanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+{
+    canvas_draw_invers(_canvas, bbox, clip, invers);
+}
+
+void CCanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    canvas_draw_rop3(_canvas, bbox, clip, rop3);
+}
+
+void CCanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    canvas_draw_stroke(_canvas, bbox, clip, stroke);
+}
+
+#ifdef WIN32
+void CCanvas::put_image(HDC dc, const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+{
+    canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
+                     clip);
+}
+
+#else
+void CCanvas::put_image(const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+{
+    canvas_put_image(_canvas, &dest, image.data, image.width, image.height, image.stride,
+                     clip);
+}
+
+#endif
+
+CanvasType CCanvas::get_pixmap_type()
+{
+    return CANVAS_TYPE_CAIRO;
+}
+
diff --git a/client/red_cairo_canvas.h b/client/red_cairo_canvas.h
new file mode 100644
index 00000000..a78627d6
--- /dev/null
+++ b/client/red_cairo_canvas.h
@@ -0,0 +1,77 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CCANVAS
+#define _H_CCANVAS
+
+#include "canvas.h"
+#include "cairo_canvas.h"
+
+class RedPixmap;
+
+class CCanvas: public Canvas {
+public:
+    CCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+            GlzDecoderWindow &glz_decoder_window);
+    virtual ~CCanvas();
+
+    virtual void set_mode(int x, int y, int bits, RedWindow *win);
+    virtual void clear();
+    virtual void thread_touch() {}
+    virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
+                             const PixmapHeader* pixmap);
+    virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
+#ifdef WIN32
+    virtual void put_image(HDC dc, const PixmapHeader& image,
+                           const Rect& dest, const QRegion* clip);
+#else
+    virtual void put_image(const PixmapHeader& image, const Rect& dest,
+                           const QRegion* clip);
+#endif
+
+    virtual CanvasType get_pixmap_type();
+
+protected:
+    virtual void set_access_params(ADDRESS delta, unsigned long base, unsigned long max);
+    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
+    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
+    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
+    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
+    virtual void draw_text(Rect *bbox, Clip *clip, Text *text);
+    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
+    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
+    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
+    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
+    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
+    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
+    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
+    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+
+private:
+    void create_pixmap(int width, int height, RedWindow *win);
+    void destroy_pixmap();
+    void destroy();
+
+private:
+    CairoCanvas* _canvas;
+    RedPixmap *_pixmap;
+    unsigned long _base;
+    unsigned long _max;
+};
+
+#endif
+
diff --git a/client/red_channel.cpp b/client/red_channel.cpp
new file mode 100644
index 00000000..4c6f1f8f
--- /dev/null
+++ b/client/red_channel.cpp
@@ -0,0 +1,714 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_channel.h"
+#include "red_client.h"
+#include "application.h"
+#include "debug.h"
+#include "utils.h"
+
+#include "openssl/rsa.h"
+#include "openssl/evp.h"
+#include "openssl/x509.h"
+
+
+RedChannelBase::RedChannelBase(uint8_t type, uint8_t id, const ChannelCaps& common_caps,
+                               const ChannelCaps& caps)
+    : RedPeer()
+    , _type (type)
+    , _id (id)
+    , _common_caps (common_caps)
+    , _caps (caps)
+{
+}
+
+RedChannelBase::~RedChannelBase()
+{
+}
+
+void RedChannelBase::link(uint32_t connection_id, const std::string& password)
+{
+    RedLinkHeader header;
+    RedLinkMess link_mess;
+    RedLinkReply* reply;
+    uint32_t link_res;
+    uint32_t i;
+
+    EVP_PKEY *pubkey;
+    int nRSASize;
+    BIO *bioKey;
+    RSA *rsa;
+
+    header.magic = RED_MAGIC;
+    header.size = sizeof(link_mess);
+    header.major_version = RED_VERSION_MAJOR;
+    header.minor_version = RED_VERSION_MINOR;
+    link_mess.connection_id = connection_id;
+    link_mess.channel_type = _type;
+    link_mess.channel_id = _id;
+    link_mess.num_common_caps = get_common_caps().size();
+    link_mess.num_channel_caps = get_caps().size();
+    link_mess.caps_offset = sizeof(link_mess);
+    header.size += (link_mess.num_common_caps + link_mess.num_channel_caps) * sizeof(uint32_t);
+    send((uint8_t*)&header, sizeof(header));
+    send((uint8_t*)&link_mess, sizeof(link_mess));
+
+    for (i = 0; i < _common_caps.size(); i++) {
+        send((uint8_t*)&_common_caps[i], sizeof(uint32_t));
+    }
+
+    for (i = 0; i < _caps.size(); i++) {
+        send((uint8_t*)&_caps[i], sizeof(uint32_t));
+    }
+
+    recive((uint8_t*)&header, sizeof(header));
+
+    if (header.magic != RED_MAGIC) {
+        THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "bad magic");
+    }
+
+    if (header.major_version != RED_VERSION_MAJOR) {
+        THROW_ERR(SPICEC_ERROR_CODE_VERSION_MISMATCH,
+                  "version mismatch: expect %u got %u",
+                  RED_VERSION_MAJOR,
+                  header.major_version);
+    }
+
+    AutoArray<uint8_t> reply_buf(new uint8_t[header.size]);
+    recive(reply_buf.get(), header.size);
+
+    reply = (RedLinkReply *)reply_buf.get();
+
+    if (reply->error != RED_ERR_OK) {
+        THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "connect error %u", reply->error);
+    }
+
+    uint32_t num_caps = reply->num_channel_caps + reply->num_common_caps;
+    if ((uint8_t *)(reply + 1) > reply_buf.get() + header.size ||
+        (uint8_t *)reply + reply->caps_offset + num_caps * sizeof(uint32_t) >
+                                                                    reply_buf.get() + header.size) {
+        THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "access violation");
+    }
+
+    uint32_t *caps = (uint32_t *)((uint8_t *)reply + reply->caps_offset);
+
+    _remote_common_caps.clear();
+    for (i = 0; i < reply->num_common_caps; i++, caps++) {
+        _remote_common_caps.resize(i + 1);
+        _remote_common_caps[i] = *caps;
+    }
+
+    _remote_caps.clear();
+    for (i = 0; i < reply->num_channel_caps; i++, caps++) {
+        _remote_caps.resize(i + 1);
+        _remote_caps[i] = *caps;
+    }
+
+    bioKey = BIO_new(BIO_s_mem());
+    if (bioKey != NULL) {
+        BIO_write(bioKey, reply->pub_key, RED_TICKET_PUBKEY_BYTES);
+        pubkey = d2i_PUBKEY_bio(bioKey, NULL);
+        rsa = pubkey->pkey.rsa;
+        nRSASize = RSA_size(rsa);
+        AutoArray<unsigned char> bufEncrypted(new unsigned char[nRSASize]);
+
+        /*
+                The use of RSA encryption limit the potential maximum password length.
+                for RSA_PKCS1_OAEP_PADDING it is RSA_size(rsa) - 41.
+        */
+        if (RSA_public_encrypt(password.length() + 1, (unsigned char *)password.c_str(),
+                               (uint8_t *)bufEncrypted.get(),
+                               rsa, RSA_PKCS1_OAEP_PADDING) > 0 ) {
+            send((uint8_t*)bufEncrypted.get(), nRSASize);
+        } else {
+            THROW("could not encrypt password");
+        }
+
+        memset(bufEncrypted.get(), 0, nRSASize);
+    } else {
+        THROW("Could not initiate BIO");
+    }
+
+    BIO_free(bioKey);
+
+    recive((uint8_t*)&link_res, sizeof(link_res));
+    if (link_res != RED_ERR_OK) {
+        int error_code = (link_res == RED_ERR_PERMISSION_DENIED) ?
+                                SPICEC_ERROR_CODE_CONNECT_FAILED : SPICEC_ERROR_CODE_CONNECT_FAILED;
+        THROW_ERR(error_code, "connect failed %u", link_res);
+    }
+}
+
+void RedChannelBase::connect(const ConnectionOptions& options, uint32_t connection_id,
+                             uint32_t ip, std::string password)
+{
+    if (options.allow_unsecure()) {
+        try {
+            RedPeer::connect_unsecure(ip, options.unsecure_port);
+            link(connection_id, password);
+            return;
+        } catch (...) {
+            if (!options.allow_secure()) {
+                throw;
+            }
+            RedPeer::close();
+        }
+    }
+    ASSERT(options.allow_secure());
+    RedPeer::connect_secure(options, ip);
+    link(connection_id, password);
+}
+
+void RedChannelBase::connect(const ConnectionOptions& options, uint32_t connection_id,
+                             const char* host, std::string password)
+{
+    connect(options, connection_id, host_by_name(host), password);
+}
+
+void RedChannelBase::set_capability(ChannelCaps& caps, uint32_t cap)
+{
+    uint32_t word_index = cap / 32;
+
+    if (caps.size() < word_index + 1) {
+        caps.resize(word_index + 1);
+    }
+    caps[word_index] |= 1 << (cap % 32);
+}
+
+void RedChannelBase::set_common_capability(uint32_t cap)
+{
+    set_capability(_common_caps, cap);
+}
+
+void RedChannelBase::set_capability(uint32_t cap)
+{
+    set_capability(_caps, cap);
+}
+
+bool RedChannelBase::test_capability(const ChannelCaps& caps, uint32_t cap)
+{
+    uint32_t word_index = cap / 32;
+
+    if (caps.size() < word_index + 1) {
+        return false;
+    }
+
+    return (caps[word_index] & (1 << (cap % 32))) != 0;
+}
+
+bool RedChannelBase::test_common_capability(uint32_t cap)
+{
+    return test_capability(_remote_common_caps, cap);
+}
+
+bool RedChannelBase::test_capability(uint32_t cap)
+{
+    return test_capability(_remote_caps, cap);
+}
+
+SendTrigger::SendTrigger(RedChannel& channel)
+    : _channel (channel)
+{
+}
+
+void SendTrigger::on_event()
+{
+    _channel.on_send_trigger();
+}
+
+void AbortTrigger::on_event()
+{
+    THROW("abort");
+}
+
+RedChannel::RedChannel(RedClient& client, uint8_t type, uint8_t id,
+                       RedChannel::MessageHandler* handler,
+                       Platform::ThreadPriority worker_priority)
+    : RedChannelBase(type, id, ChannelCaps(), ChannelCaps())
+    , _client (client)
+    , _state (PASSIVE_STATE)
+    , _action (WAIT_ACTION)
+    , _error (SPICEC_ERROR_CODE_SUCCESS)
+    , _wait_for_threads (true)
+    , _socket_in_loop (false)
+    , _worker (NULL)
+    , _worker_priority (worker_priority)
+    , _message_handler (handler)
+    , _outgoing_message (NULL)
+    , _incomming_header_pos (0)
+    , _incomming_message (NULL)
+    , _message_ack_count (0)
+    , _message_ack_window (0)
+    , _send_trigger (*this)
+    , _disconnect_stamp (0)
+    , _disconnect_reason (RED_ERR_OK)
+{
+    _loop.add_trigger(_send_trigger);
+    _loop.add_trigger(_abort_trigger);
+}
+
+RedChannel::~RedChannel()
+{
+    ASSERT(_state == TERMINATED_STATE || _state == PASSIVE_STATE);
+    delete _worker;
+}
+
+void* RedChannel::worker_main(void *data)
+{
+    try {
+        RedChannel* channel = static_cast<RedChannel*>(data);
+        channel->set_state(DISCONNECTED_STATE);
+        Platform::set_thread_priority(NULL, channel->get_worker_priority());
+        channel->run();
+    } catch (Exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+    } catch (std::exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+    } catch (...) {
+        LOG_ERROR("unhandled exception");
+    }
+    return NULL;
+}
+
+void RedChannel::post_message(RedChannel::OutMessage* message)
+{
+    Lock lock(_outgoing_lock);
+    _outgoing_messages.push_back(message);
+    lock.unlock();
+    _send_trigger.trigger();
+}
+
+RedPeer::CompundInMessage *RedChannel::recive()
+{
+    CompundInMessage *message = RedChannelBase::recive();
+    on_message_recived();
+    return message;
+}
+
+RedChannel::OutMessage* RedChannel::get_outgoing_message()
+{
+    if (_state != CONNECTED_STATE || _outgoing_messages.empty()) {
+        return NULL;
+    }
+    RedChannel::OutMessage* message = _outgoing_messages.front();
+    _outgoing_messages.pop_front();
+    return message;
+}
+
+class AutoMessage {
+public:
+    AutoMessage(RedChannel::OutMessage* message) : _message (message) {}
+    ~AutoMessage() {if (_message) _message->release();}
+    void set(RedChannel::OutMessage* message) { _message = message;}
+    RedChannel::OutMessage* get() { return _message;}
+    RedChannel::OutMessage* release();
+
+private:
+    RedChannel::OutMessage* _message;
+};
+
+RedChannel::OutMessage* AutoMessage::release()
+{
+    RedChannel::OutMessage* ret = _message;
+    _message = NULL;
+    return ret;
+}
+
+void RedChannel::start()
+{
+    ASSERT(!_worker);
+    _worker = new Thread(RedChannel::worker_main, this);
+    Lock lock(_state_lock);
+    while (_state == PASSIVE_STATE) {
+        _state_cond.wait(lock);
+    }
+}
+
+void RedChannel::set_state(int state)
+{
+    Lock lock(_state_lock);
+    _state = state;
+    _state_cond.notify_all();
+}
+
+void RedChannel::connect()
+{
+    Lock lock(_action_lock);
+
+    if (_state != DISCONNECTED_STATE && _state != PASSIVE_STATE) {
+        return;
+    }
+    _action = CONNECT_ACTION;
+    _action_cond.notify_one();
+}
+
+void RedChannel::disconnect()
+{
+    clear_outgoing_messages();
+
+    Lock lock(_action_lock);
+    if (_state != CONNECTING_STATE && _state != CONNECTED_STATE) {
+        return;
+    }
+    _action = DISCONNECT_ACTION;
+    RedPeer::disconnect();
+    _action_cond.notify_one();
+}
+
+void RedChannel::clear_outgoing_messages()
+{
+    Lock lock(_outgoing_lock);
+    while (!_outgoing_messages.empty()) {
+        RedChannel::OutMessage* message = _outgoing_messages.front();
+        _outgoing_messages.pop_front();
+        message->release();
+    }
+}
+
+void RedChannel::run()
+{
+    for (;;) {
+        Lock lock(_action_lock);
+        if (_action == WAIT_ACTION) {
+            _action_cond.wait(lock);
+        }
+        int action = _action;
+        _action = WAIT_ACTION;
+        lock.unlock();
+        switch (action) {
+        case CONNECT_ACTION:
+            try {
+                get_client().get_sync_info(get_type(), get_id(), _sync_info);
+                on_connecting();
+                set_state(CONNECTING_STATE);
+                ConnectionOptions con_options(_client.get_connection_options(get_type()),
+                                              _client.get_port(),
+                                              _client.get_sport());
+                RedChannelBase::connect(con_options, _client.get_connection_id(),
+                                        _client.get_host(), _client.get_password());
+                on_connect();
+                set_state(CONNECTED_STATE);
+                _loop.add_socket(*this);
+                _socket_in_loop = true;
+                on_event();
+                _loop.run();
+            } catch (RedPeer::DisconnectedException&) {
+                _error = SPICEC_ERROR_CODE_SUCCESS;
+            } catch (Exception& e) {
+                LOG_WARN("%s", e.what());
+                _error = e.get_error_code();
+            } catch (std::exception& e) {
+                LOG_WARN("%s", e.what());
+                _error = SPICEC_ERROR_CODE_ERROR;
+            }
+            if (_socket_in_loop) {
+                _socket_in_loop = false;
+                _loop.remove_socket(*this);
+            }
+            if (_outgoing_message) {
+                _outgoing_message->release();
+                _outgoing_message = NULL;
+            }
+            _incomming_header_pos = 0;
+            delete _incomming_message;
+            _incomming_message = NULL;
+        case DISCONNECT_ACTION:
+            close();
+            on_disconnect();
+            set_state(DISCONNECTED_STATE);
+            _client.on_channel_disconnected(*this);
+            continue;
+        case QUIT_ACTION:
+            set_state(TERMINATED_STATE);
+            return;
+        }
+    }
+}
+
+bool RedChannel::abort()
+{
+    clear_outgoing_messages();
+    Lock lock(_action_lock);
+    if (_state == TERMINATED_STATE) {
+        if (_wait_for_threads) {
+            _wait_for_threads = false;
+            _worker->join();
+        }
+        return true;
+    }
+
+    _action = QUIT_ACTION;
+    _action_cond.notify_one();
+    lock.unlock();
+    RedPeer::disconnect();
+    _abort_trigger.trigger();
+
+    for (;;) {
+        Lock state_lock(_state_lock);
+        if (_state == TERMINATED_STATE) {
+            break;
+        }
+        uint64_t timout = 1000 * 1000 * 100; // 100ms
+        if (!_state_cond.timed_wait(state_lock, timout)) {
+            return false;
+        }
+    }
+    if (_wait_for_threads) {
+        _wait_for_threads = false;
+        _worker->join();
+    }
+    return true;
+}
+
+void RedChannel::send_messages()
+{
+    if (_outgoing_message) {
+        return;
+    }
+
+    for (;;) {
+        Lock lock(_outgoing_lock);
+        AutoMessage message(get_outgoing_message());
+        if (!message.get()) {
+            return;
+        }
+        RedPeer::OutMessage& peer_message = message.get()->peer_message();
+        uint32_t n = send(peer_message);
+        if (n != peer_message.message_size()) {
+            _outgoing_message = message.release();
+            _outgoing_pos = n;
+            return;
+        }
+    }
+}
+
+void RedChannel::on_send_trigger()
+{
+    send_messages();
+}
+
+void RedChannel::on_message_recived()
+{
+    if (_message_ack_count && !--_message_ack_count) {
+        post_message(new Message(REDC_ACK, 0));
+        _message_ack_count = _message_ack_window;
+    }
+}
+
+void RedChannel::on_message_complition(uint64_t serial)
+{
+    Lock lock(*_sync_info.lock);
+    *_sync_info.message_serial = serial;
+    _sync_info.condition->notify_all();
+}
+
+void RedChannel::recive_messages()
+{
+    for (;;) {
+        uint32_t n = RedPeer::recive((uint8_t*)&_incomming_header, sizeof(RedDataHeader));
+        if (n != sizeof(RedDataHeader)) {
+            _incomming_header_pos = n;
+            return;
+        }
+        std::auto_ptr<CompundInMessage> message(new CompundInMessage(_incomming_header.serial,
+                                                                     _incomming_header.type,
+                                                                     _incomming_header.size,
+                                                                     _incomming_header.sub_list));
+        n = RedPeer::recive(message->data(), message->compund_size());
+        if (n != message->compund_size()) {
+            _incomming_message = message.release();
+            _incomming_message_pos = n;
+            return;
+        }
+        on_message_recived();
+        _message_handler->handle_message(*message.get());
+        on_message_complition(message->serial());
+    }
+}
+
+void RedChannel::on_event()
+{
+    if (_outgoing_message) {
+        RedPeer::OutMessage& peer_message = _outgoing_message->peer_message();
+        _outgoing_pos += send(peer_message.base() + _outgoing_pos,
+                              peer_message.message_size() - _outgoing_pos);
+        if (_outgoing_pos == peer_message.message_size()) {
+            _outgoing_message->release();
+            _outgoing_message = NULL;
+        }
+    }
+    send_messages();
+
+    if (_incomming_header_pos) {
+        _incomming_header_pos += RedPeer::recive(((uint8_t*)&_incomming_header) +
+                                                 _incomming_header_pos,
+                                                 sizeof(RedDataHeader) - _incomming_header_pos);
+        if (_incomming_header_pos != sizeof(RedDataHeader)) {
+            return;
+        }
+        _incomming_header_pos = 0;
+        _incomming_message = new CompundInMessage(_incomming_header.serial,
+                                                  _incomming_header.type,
+                                                  _incomming_header.size,
+                                                  _incomming_header.sub_list);
+        _incomming_message_pos = 0;
+    }
+
+    if (_incomming_message) {
+        _incomming_message_pos += RedPeer::recive(_incomming_message->data() +
+                                                  _incomming_message_pos,
+                                                  _incomming_message->compund_size() -
+                                                  _incomming_message_pos);
+        if (_incomming_message_pos != _incomming_message->compund_size()) {
+            return;
+        }
+        std::auto_ptr<CompundInMessage> message(_incomming_message);
+        _incomming_message = NULL;
+        on_message_recived();
+        _message_handler->handle_message(*message.get());
+        on_message_complition(message->serial());
+    }
+    recive_messages();
+}
+
+void RedChannel::send_migrate_flush_mark()
+{
+    if (_outgoing_message) {
+        RedPeer::OutMessage& peer_message = _outgoing_message->peer_message();
+        send(peer_message.base() + _outgoing_pos, peer_message.message_size() - _outgoing_pos);
+        _outgoing_message->release();
+        _outgoing_message = NULL;
+    }
+    Lock lock(_outgoing_lock);
+    for (;;) {
+        AutoMessage message(get_outgoing_message());
+        if (!message.get()) {
+            break;
+        }
+        send(message.get()->peer_message());
+    }
+    lock.unlock();
+    std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(REDC_MIGRATE_FLUSH_MARK, 0));
+    send(*message);
+}
+
+void RedChannel::handle_migrate(RedPeer::InMessage* message)
+{
+    DBG(0, "channel type %u id %u", get_type(), get_id());
+    _socket_in_loop = false;
+    _loop.remove_socket(*this);
+    RedMigrate* migrate = (RedMigrate*)message->data();
+    if (migrate->flags & RED_MIGRATE_NEED_FLUSH) {
+        send_migrate_flush_mark();
+    }
+    std::auto_ptr<RedPeer::CompundInMessage> data_message;
+    if (migrate->flags & RED_MIGRATE_NEED_DATA_TRANSFER) {
+        data_message.reset(recive());
+    }
+    _client.migrate_channel(*this);
+    if (migrate->flags & RED_MIGRATE_NEED_DATA_TRANSFER) {
+        if (data_message->type() != RED_MIGRATE_DATA) {
+            THROW("expect RED_MIGRATE_DATA");
+        }
+        std::auto_ptr<RedPeer::OutMessage> message(new RedPeer::OutMessage(REDC_MIGRATE_DATA,
+                                                                           data_message->size()));
+        memcpy(message->data(), data_message->data(), data_message->size());
+        send(*message);
+    }
+    _loop.add_socket(*this);
+    _socket_in_loop = true;
+    on_migrate();
+    set_state(CONNECTED_STATE);
+    on_event();
+}
+
+void RedChannel::handle_set_ack(RedPeer::InMessage* message)
+{
+    RedSetAck* ack = (RedSetAck*)message->data();
+    _message_ack_window = _message_ack_count = ack->window;
+    Message *responce = new Message(REDC_ACK_SYNC, sizeof(uint32_t));
+    *(uint32_t *)responce->data() = ack->generation;
+    post_message(responce);
+}
+
+void RedChannel::handle_ping(RedPeer::InMessage* message)
+{
+    RedPing *ping = (RedPing *)message->data();
+    Message *pong = new Message(REDC_PONG, sizeof(RedPing));
+    *(RedPing *)pong->data() = *ping;
+    post_message(pong);
+}
+
+void RedChannel::handle_disconnect(RedPeer::InMessage* message)
+{
+    RedDisconnect *disconnect = (RedDisconnect *)message->data();
+    _disconnect_stamp = disconnect->time_stamp;
+    _disconnect_reason = disconnect->reason;
+}
+
+void RedChannel::handle_notify(RedPeer::InMessage* message)
+{
+    RedNotify *notify = (RedNotify *)message->data();
+    const char *sevirity;
+    const char *visibility;
+    const char *message_str = "";
+    const char *message_prefix = "";
+
+    static const char* sevirity_strings[] = {"info", "warn", "error"};
+    static const char* visibility_strings[] = {"!", "!!", "!!!"};
+
+
+    if (notify->severty > RED_NOTIFY_SEVERITY_ERROR) {
+        THROW("bad sevirity");
+    }
+    sevirity = sevirity_strings[notify->severty];
+
+    if (notify->visibilty > RED_NOTIFY_VISIBILITY_HIGH) {
+        THROW("bad visibilty");
+    }
+    visibility = visibility_strings[notify->visibilty];
+
+
+    if (notify->message_len) {
+        if ((message->size() - sizeof(*notify) < notify->message_len + 1)) {
+            THROW("access violation");
+        }
+        message_str = (char *)(notify + 1);
+        if (message_str[notify->message_len] != 0) {
+            THROW("invalid message");
+        }
+        message_prefix = ": ";
+    }
+
+
+    LOG_INFO("remote channel %u:%u %s%s #%u%s%s",
+             get_type(), get_id(),
+             sevirity, visibility,
+             notify->what,
+             message_prefix, message_str);
+}
+
+void RedChannel::handle_wait_for_channels(RedPeer::InMessage* message)
+{
+    RedWaitForChannels *wait = (RedWaitForChannels *)message->data();
+    if (message->size() < sizeof(*wait) + wait->wait_count * sizeof(wait->wait_list[0])) {
+        THROW("access violation");
+    }
+    _client.wait_for_channels(wait->wait_count, wait->wait_list);
+}
+
diff --git a/client/red_channel.h b/client/red_channel.h
new file mode 100644
index 00000000..0ffe051a
--- /dev/null
+++ b/client/red_channel.h
@@ -0,0 +1,296 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REDCHANNEL
+#define _H_REDCHANNEL
+
+#include "common.h"
+#include "utils.h"
+#include "threads.h"
+#include "red_peer.h"
+#include "platform.h"
+#include "events_loop.h"
+
+enum {
+    PASSIVE_STATE,
+    DISCONNECTED_STATE,
+    CONNECTING_STATE,
+    CONNECTED_STATE,
+    TERMINATED_STATE,
+};
+
+enum {
+    WAIT_ACTION,
+    CONNECT_ACTION,
+    DISCONNECT_ACTION,
+    QUIT_ACTION,
+};
+
+class RedClient;
+class RedChannel;
+
+typedef std::vector<uint32_t> ChannelCaps;
+
+class RedChannelBase: public RedPeer {
+public:
+    RedChannelBase(uint8_t type, uint8_t id, const ChannelCaps& common_caps,
+                   const ChannelCaps& caps);
+
+    virtual ~RedChannelBase();
+
+    uint8_t get_type() { return _type;}
+    uint8_t get_id() { return _id;}
+
+    void connect(const ConnectionOptions& options, uint32_t connection_id, uint32_t ip,
+                 std::string password);
+    void connect(const ConnectionOptions& options, uint32_t connection_id, const char *host,
+                 std::string password);
+
+    const ChannelCaps& get_common_caps() { return _common_caps;}
+    const ChannelCaps& get_caps() {return _caps;}
+
+protected:
+    void set_common_capability(uint32_t cap);
+    void set_capability(uint32_t cap);
+    bool test_common_capability(uint32_t cap);
+    bool test_capability(uint32_t cap);
+
+private:
+    void set_capability(ChannelCaps& caps, uint32_t cap);
+    bool test_capability(const ChannelCaps& caps, uint32_t cap);
+    void link(uint32_t connection_id, const std::string& password);
+
+private:
+    uint8_t _type;
+    uint8_t _id;
+
+    ChannelCaps _common_caps;
+    ChannelCaps _caps;
+
+    ChannelCaps _remote_common_caps;
+    ChannelCaps _remote_caps;
+};
+
+class SendTrigger: public EventsLoop::Trigger {
+public:
+    SendTrigger(RedChannel& channel);
+
+    virtual void on_event();
+
+private:
+    RedChannel& _channel;
+};
+
+class AbortTrigger: public EventsLoop::Trigger {
+public:
+    virtual void on_event();
+};
+
+struct SyncInfo {
+    Mutex* lock;
+    Condition* condition;
+    uint64_t* message_serial;
+};
+
+class RedChannel: public RedChannelBase {
+public:
+    friend class RedCannel;
+    class MessageHandler;
+    class OutMessage;
+
+    RedChannel(RedClient& client, uint8_t type, uint8_t id, MessageHandler* handler,
+               Platform::ThreadPriority worker_priority = Platform::PRIORITY_NORMAL);
+    virtual ~RedChannel();
+    void start();
+
+    virtual void connect();
+    virtual void disconnect();
+    virtual bool abort();
+
+    virtual CompundInMessage *recive();
+
+    virtual void post_message(RedChannel::OutMessage* message);
+    int get_connection_error() { return _error;}
+    Platform::ThreadPriority get_worker_priority() { return _worker_priority;}
+
+protected:
+    RedClient& get_client() { return _client;}
+    EventsLoop& get_events_loop() { return _loop;}
+    MessageHandler* get_message_handler() { return _message_handler.get();}
+    virtual void on_connecting() {}
+    virtual void on_connect() {}
+    virtual void on_disconnect() {}
+    virtual void on_migrate() {}
+    void handle_migrate(RedPeer::InMessage* message);
+    void handle_set_ack(RedPeer::InMessage* message);
+    void handle_ping(RedPeer::InMessage* message);
+    void handle_wait_for_channels(RedPeer::InMessage* message);
+    void handle_disconnect(RedPeer::InMessage* message);
+    void handle_notify(RedPeer::InMessage* message);
+
+private:
+    void set_state(int state);
+    void run();
+    void send_migrate_flush_mark();
+    void send_messages();
+    void recive_messages();
+    void on_send_trigger();
+    virtual void on_event();
+    void on_message_recived();
+    void on_message_complition(uint64_t serial);
+
+    static void* worker_main(void *);
+
+    RedChannel::OutMessage* get_outgoing_message();
+    void clear_outgoing_messages();
+
+private:
+    RedClient& _client;
+    int _state;
+    int _action;
+    int _error;
+    bool _wait_for_threads;
+    bool _socket_in_loop;
+
+    Thread* _worker;
+    Platform::ThreadPriority _worker_priority;
+    std::auto_ptr<MessageHandler> _message_handler;
+    Mutex _state_lock;
+    Condition _state_cond;
+    Mutex _action_lock;
+    Condition _action_cond;
+    SyncInfo _sync_info;
+
+    Mutex _outgoing_lock;
+    std::list<RedChannel::OutMessage*> _outgoing_messages;
+    RedChannel::OutMessage* _outgoing_message;
+    uint32_t _outgoing_pos;
+
+    RedDataHeader _incomming_header;
+    uint32_t _incomming_header_pos;
+    RedPeer::CompundInMessage* _incomming_message;
+    uint32_t _incomming_message_pos;
+
+    uint32_t _message_ack_count;
+    uint32_t _message_ack_window;
+
+    EventsLoop _loop;
+    SendTrigger _send_trigger;
+    AbortTrigger _abort_trigger;
+
+    uint64_t _disconnect_stamp;
+    uint64_t _disconnect_reason;
+
+    friend class SendTrigger;
+};
+
+
+class RedChannel::OutMessage {
+public:
+    OutMessage() {}
+    virtual ~OutMessage() {}
+
+    virtual RedPeer::OutMessage& peer_message() = 0;
+    virtual void release() = 0;
+};
+
+class Message: public RedChannel::OutMessage, public RedPeer::OutMessage {
+public:
+    Message(uint32_t type, uint32_t size)
+        : RedChannel::OutMessage()
+        , RedPeer::OutMessage(type, size)
+    {
+    }
+
+    virtual RedPeer::OutMessage& peer_message() { return *this;}
+    virtual void release() {delete this;}
+};
+
+
+class RedChannel::MessageHandler {
+public:
+    MessageHandler() {}
+    virtual ~MessageHandler() {}
+    virtual void handle_message(RedPeer::CompundInMessage& message) = 0;
+};
+
+
+template <class HandlerClass, unsigned int end_message>
+class MessageHandlerImp: public RedChannel::MessageHandler {
+public:
+    MessageHandlerImp(HandlerClass& obj);
+    virtual ~MessageHandlerImp() {}
+    virtual void handle_message(RedPeer::CompundInMessage& message);
+    typedef void (HandlerClass::*Handler)(RedPeer::InMessage* message);
+    void set_handler(unsigned int id, Handler handler, size_t mess_size);
+
+private:
+    HandlerClass& _obj;
+    struct HandlerInfo {
+        Handler handler;
+        size_t mess_size;
+    };
+
+    HandlerInfo _handlers[end_message];
+};
+
+template <class HandlerClass, unsigned int end_message>
+MessageHandlerImp<HandlerClass, end_message>::MessageHandlerImp(HandlerClass& obj)
+    : _obj (obj)
+{
+    memset(_handlers, 0, sizeof(_handlers));
+}
+
+template <class HandlerClass, unsigned int end_message>
+void MessageHandlerImp<HandlerClass, end_message>::handle_message(RedPeer::CompundInMessage&
+                                                                                            message)
+{
+    if (message.type() >= end_message || !_handlers[message.type()].handler) {
+        THROW("bad message type %d", message.type());
+    }
+    if (message.size() < _handlers[message.type()].mess_size) {
+        THROW("bad message size, type %d size %d expected %d",
+              message.type(),
+              message.size(),
+              _handlers[message.type()].mess_size);
+    }
+    if (message.sub_list()) {
+        RedSubMessageList *sub_list;
+        sub_list = (RedSubMessageList *)(message.data() + message.sub_list());
+        for (int i = 0; i < sub_list->size; i++) {
+            RedSubMessage *sub = (RedSubMessage *)(message.data() + sub_list->sub_messages[i]);
+            //todo: test size
+            RedPeer::InMessage sub_message(sub->type, sub->size, (uint8_t *)(sub + 1));
+            (_obj.*_handlers[sub_message.type()].handler)(&sub_message);
+        }
+    }
+    (_obj.*_handlers[message.type()].handler)(&message);
+}
+
+template <class HandlerClass, unsigned int end_message>
+void MessageHandlerImp<HandlerClass, end_message>::set_handler(unsigned int id, Handler handler,
+                                                               size_t mess_size)
+{
+    if (id >= end_message) {
+        THROW("bad handler id");
+    }
+    _handlers[id].handler = handler;
+    _handlers[id].mess_size = mess_size;
+}
+
+#endif
+
diff --git a/client/red_client.cpp b/client/red_client.cpp
new file mode 100644
index 00000000..941321fb
--- /dev/null
+++ b/client/red_client.cpp
@@ -0,0 +1,811 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <math.h>
+#include "red_client.h"
+#include "application.h"
+#include "utils.h"
+#include "debug.h"
+
+Migrate::Migrate(RedClient& client)
+    : _client (client)
+    , _running (false)
+    , _aborting (false)
+    , _connected (false)
+    , _thread (NULL)
+    , _pending_con (0)
+{
+}
+
+Migrate::~Migrate()
+{
+    ASSERT(!_thread);
+    delete_channels();
+}
+
+void Migrate::delete_channels()
+{
+    while (!_channels.empty()) {
+        MigChannels::iterator iter = _channels.begin();
+        delete *iter;
+        _channels.erase(iter);
+    }
+}
+
+void Migrate::clear_channels()
+{
+    Lock lock(_lock);
+    ASSERT(!_running);
+    delete_channels();
+}
+
+void Migrate::add_channel(MigChannel* channel)
+{
+    Lock lock(_lock);
+    _channels.push_back(channel);
+}
+
+void Migrate::swap_peer(RedChannelBase& other)
+{
+    DBG(0, "channel type %u id %u", other.get_type(), other.get_id());
+    try {
+        Lock lock(_lock);
+        MigChannels::iterator iter = _channels.begin();
+
+        if (_running) {
+            THROW("swap and running");
+        }
+
+        if (!_connected) {
+            THROW("not connected");
+        }
+
+        for (; iter != _channels.end(); ++iter) {
+            MigChannel* curr = *iter;
+            if (curr->get_type() == other.get_type() && curr->get_id() == other.get_id()) {
+                if (!curr->is_valid()) {
+                    THROW("invalid");
+                }
+                other.swap(curr);
+                curr->set_valid(false);
+                if (!--_pending_con) {
+                    lock.unlock();
+                    _client.set_target(_host.c_str(), _port, _sport);
+                    abort();
+                }
+                return;
+            }
+        }
+        THROW("no channel");
+    } catch (...) {
+        abort();
+        throw;
+    }
+}
+
+void Migrate::connect_one(MigChannel& channel, const RedPeer::ConnectionOptions& options,
+                          uint32_t connection_id)
+{
+    if (_aborting) {
+        DBG(0, "aborting");
+        THROW("aborting");
+    }
+    channel.connect(options, connection_id, _host.c_str(), _password);
+    ++_pending_con;
+    channel.set_valid(true);
+}
+
+void Migrate::run()
+{
+    uint32_t connection_id;
+
+    DBG(0, "");
+    try {
+        RedPeer::ConnectionOptions con_opt(_client.get_connection_options(RED_CHANNEL_MAIN),
+                                           _port, _port);
+        MigChannels::iterator iter = _channels.begin();
+        connection_id = _client.get_connection_id();
+        connect_one(**iter, con_opt, connection_id);
+        for (++iter; iter != _channels.end(); ++iter) {
+            con_opt = RedPeer::ConnectionOptions(
+                                                _client.get_connection_options((*iter)->get_type()),
+                                                _port, _sport);
+            connect_one(**iter, con_opt, connection_id);
+        }
+        _connected = true;
+        DBG(0, "connected");
+    } catch (...) {
+        close_channels();
+    }
+
+    Lock lock(_lock);
+    _cond.notify_one();
+    if (_connected) {
+        Message* message = new Message(REDC_MIGRATE_CONNECTED, 0);
+        _client.post_message(message);
+    } else {
+        Message* message = new Message(REDC_MIGRATE_CONNECT_ERROR, 0);
+        _client.post_message(message);
+    }
+    _running = false;
+}
+
+void* Migrate::worker_main(void *data)
+{
+    Migrate* mig = (Migrate*)data;
+    mig->run();
+    return NULL;
+}
+
+void Migrate::start(const RedMigrationBegin* migrate)
+{
+    DBG(0, "");
+    abort();
+    _host.assign(migrate->host);
+    _port = migrate->port ? migrate->port : -1;
+    _sport = migrate->sport ? migrate->sport : -1;
+    _password = _client._password;
+    Lock lock(_lock);
+    _running = true;
+    lock.unlock();
+    _thread = new Thread(Migrate::worker_main, this);
+}
+
+void Migrate::disconnect_channels()
+{
+    MigChannels::iterator iter = _channels.begin();
+
+    for (; iter != _channels.end(); ++iter) {
+        (*iter)->disconnect();
+        (*iter)->set_valid(false);
+    }
+}
+
+void Migrate::close_channels()
+{
+    MigChannels::iterator iter = _channels.begin();
+
+    for (; iter != _channels.end(); ++iter) {
+        (*iter)->close();
+        (*iter)->set_valid(false);
+        (*iter)->enable();
+    }
+}
+
+bool Migrate::abort()
+{
+    Lock lock(_lock);
+    if (_aborting) {
+        return false;
+    }
+    _aborting = true;
+    for (;;) {
+        disconnect_channels();
+        if (!_running) {
+            break;
+        }
+        uint64_t timout = 1000 * 1000 * 10; /*10ms*/
+        _cond.timed_wait(lock, timout);
+    }
+    close_channels();
+    _pending_con = 0;
+    _connected = false;
+    _aborting = false;
+    if (_thread) {
+        _thread->join();
+        delete _thread;
+        _thread = NULL;
+    }
+    return true;
+}
+
+#define AGENT_TIMEOUT (1000 * 30)
+
+void agent_timer_proc(void *opaque, TimerID timer)
+{
+    Platform::deactivate_interval_timer(timer);
+    THROW_ERR(SPICEC_ERROR_CODE_AGENT_TIMEOUT, "vdagent timeout");
+}
+
+class MainChannelLoop: public MessageHandlerImp<RedClient, RED_MESSAGES_END> {
+public:
+    MainChannelLoop(RedClient& client): MessageHandlerImp<RedClient, RED_MESSAGES_END>(client) {}
+};
+
+RedClient::RedClient(Application& application)
+    : RedChannel(*this, RED_CHANNEL_MAIN, 0, new MainChannelLoop(*this))
+    , _application (application)
+    , _connection_id (0)
+    , _mouse_mode (RED_MOUSE_MODE_SERVER)
+    , _notify_disconnect (false)
+    , _aborting (false)
+    , _agent_connected (false)
+    , _agent_mon_config_sent (false)
+    , _agent_msg (new VDAgentMessage)
+    , _agent_msg_data (NULL)
+    , _agent_msg_pos (0)
+    , _agent_tokens (0)
+    , _agent_timer (Platform::create_interval_timer(agent_timer_proc, NULL))
+    , _migrate (*this)
+    , _glz_window (0, _glz_debug)
+{
+    MainChannelLoop* message_loop = static_cast<MainChannelLoop*>(get_message_handler());
+
+    message_loop->set_handler(RED_MIGRATE, &RedClient::handle_migrate, 0);
+    message_loop->set_handler(RED_SET_ACK, &RedClient::handle_set_ack, sizeof(RedSetAck));
+    message_loop->set_handler(RED_PING, &RedClient::handle_ping, sizeof(RedPing));
+    message_loop->set_handler(RED_WAIT_FOR_CHANNELS, &RedClient::handle_wait_for_channels,
+                              sizeof(RedWaitForChannels));
+    message_loop->set_handler(RED_DISCONNECTING, &RedClient::handle_disconnect,
+                              sizeof(RedDisconnect));
+    message_loop->set_handler(RED_NOTIFY, &RedClient::handle_notify, sizeof(RedNotify));
+
+    message_loop->set_handler(RED_MIGRATE_BEGIN, &RedClient::handle_migrate_begin,
+                              sizeof(RedMigrationBegin));
+    message_loop->set_handler(RED_MIGRATE_CANCEL, &RedClient::handle_migrate_cancel, 0);
+    message_loop->set_handler(RED_INIT, &RedClient::handle_init, sizeof(RedInit));
+    message_loop->set_handler(RED_CHANNELS_LIST, &RedClient::handle_channels,
+                              sizeof(RedChannels));
+    message_loop->set_handler(RED_MOUSE_MODE, &RedClient::handle_mouse_mode,
+                              sizeof(RedMouseMode));
+    message_loop->set_handler(RED_MULTI_MEDIA_TIME, &RedClient::handle_mm_time,
+                              sizeof(RedMultiMediaTime));
+
+    message_loop->set_handler(RED_AGENT_CONNECTED, &RedClient::handle_agent_connected, 0);
+    message_loop->set_handler(RED_AGENT_DISCONNECTED, &RedClient::handle_agent_disconnected,
+                              sizeof(RedAgentDisconnect));
+    message_loop->set_handler(RED_AGENT_DATA, &RedClient::handle_agent_data, 0);
+    message_loop->set_handler(RED_AGENT_TOKEN, &RedClient::handle_agent_tokens,
+                              sizeof(RedAgentTokens));
+    if (_agent_timer == INVALID_TIMER) {
+        THROW("invalid agent timer");
+    }
+    start();
+}
+
+RedClient::~RedClient()
+{
+    ASSERT(_channels.empty());
+    Platform::destroy_interval_timer(_agent_timer);
+    delete _agent_msg;
+}
+
+void RedClient::init(const char* host, int port, int sport, const char *password,
+                     bool auto_display_res)
+{
+    _host = host;
+    _port = port;
+    _sport = sport;
+    _auto_display_res = auto_display_res;
+
+    if (password != NULL) {
+        _password = password;
+    } else {
+        _password = "";
+    }
+}
+
+void RedClient::set_target(const char* host, uint16_t port, uint16_t sport)
+{
+    _port = port;
+    _sport = sport;
+    _host.assign(host);
+}
+
+void RedClient::push_event(Event* event)
+{
+    _application.push_event(event);
+}
+
+void RedClient::on_connecting()
+{
+    _notify_disconnect = true;
+}
+
+void RedClient::on_connect()
+{
+    push_event(new ConnectedEvent());
+    _migrate.add_channel(new MigChannel(RED_CHANNEL_MAIN, 0, get_common_caps(),
+                                        get_caps()));
+}
+
+void RedClient::on_disconnect()
+{
+    _migrate.abort();
+    _connection_id = 0;
+    Platform::deactivate_interval_timer(_agent_timer);
+    _agent_mon_config_sent = false;
+    delete[] _agent_msg_data;
+    _agent_msg_data = NULL;
+    _agent_msg_pos = 0;
+    _agent_tokens = 0;
+}
+
+void RedClient::delete_channels()
+{
+    Lock lock(_channels_lock);
+    Channels::iterator iter = _channels.begin();
+    while (!_channels.empty()) {
+        RedChannel *channel = *_channels.begin();
+        _channels.pop_front();
+        delete channel;
+    }
+}
+
+RedPeer::ConnectionOptions::Type RedClient::get_connection_options(uint32_t channel_type)
+{
+    return _con_opt_map[channel_type];
+}
+
+void RedClient::connect()
+{
+    //todo wait for disconnect state
+    if (_connection_id || !abort_channels()) {
+        return;
+    }
+    _pixmap_cache.clear();
+    _glz_window.clear();
+    memset(_sync_info, 0, sizeof(_sync_info));
+    _aborting = false;
+    _migrate.clear_channels();
+    delete_channels();
+    enable();
+
+    _con_opt_map.clear();
+    PeerConnectionOptMap::const_iterator iter = _application.get_con_opt_map().begin();
+    PeerConnectionOptMap::const_iterator end = _application.get_con_opt_map().end();
+    for (; iter != end; iter++) {
+        _con_opt_map[(*iter).first] = (*iter).second;
+    }
+    RedChannel::connect();
+}
+
+void RedClient::disconnect()
+{
+    _migrate.abort();
+    RedChannel::disconnect();
+}
+
+void RedClient::disconnect_channels()
+{
+    Lock lock(_channels_lock);
+    Channels::iterator iter = _channels.begin();
+    for (; iter != _channels.end(); ++iter) {
+        (*iter)->RedPeer::disconnect();
+    }
+}
+
+void RedClient::on_channel_disconnected(RedChannel& channel)
+{
+    Lock lock(_notify_lock);
+    if (_notify_disconnect) {
+        _notify_disconnect = false;
+        int connection_error = channel.get_connection_error();
+        if (connection_error == SPICEC_ERROR_CODE_SUCCESS) {
+            LOG_INFO("disconneted");
+            push_event(new DisconnectedEvent());
+        } else {
+            push_event(new CoonnectionError(connection_error));
+        }
+    }
+    disconnect_channels();
+    RedPeer::disconnect();
+}
+
+bool RedClient::abort_channels()
+{
+    Lock lock(_channels_lock);
+    Channels::iterator iter = _channels.begin();
+
+    for (; iter != _channels.end(); ++iter) {
+        if (!(*iter)->abort()) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool RedClient::abort()
+{
+    if (!_aborting) {
+        Lock lock(_sync_lock);
+        _aborting = true;
+        _sync_condition.notify_all();
+    }
+    _pixmap_cache.abort();
+    _glz_window.abort();
+    if (RedChannel::abort() && abort_channels()) {
+        delete_channels();
+        _migrate.abort();
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void RedClient::handle_migrate_begin(RedPeer::InMessage* message)
+{
+    DBG(0, "");
+    RedMigrationBegin* migrate = (RedMigrationBegin*)message->data();
+    //add mig channels
+    _migrate.start(migrate);
+}
+
+void RedClient::handle_migrate_cancel(RedPeer::InMessage* message)
+{
+    _migrate.abort();
+}
+
+ChannelFactory* RedClient::find_factory(uint32_t type)
+{
+    Factorys::iterator iter = _factorys.begin();
+    for (; iter != _factorys.end(); ++iter) {
+        if ((*iter)->type() == type) {
+            return *iter;
+        }
+    }
+    LOG_WARN("no factory for %u", type);
+    return NULL;
+}
+
+void RedClient::create_channel(uint32_t type, uint32_t id)
+{
+    ChannelFactory* factory = find_factory(type);
+    if (!factory) {
+        return;
+    }
+    RedChannel* channel = factory->construct(*this, id);
+    ASSERT(channel);
+    Lock lock(_channels_lock);
+    _channels.push_back(channel);
+    channel->start();
+    channel->connect();
+    _migrate.add_channel(new MigChannel(type, id, channel->get_common_caps(), channel->get_caps()));
+}
+
+void RedClient::send_agent_monitors_config()
+{
+    AutoRef<MonitorsQuery > qury(new MonitorsQuery());
+    push_event(*qury);
+    (*qury)->wait();
+    if (!(*qury)->success()) {
+        THROW(" monitors query failed");
+    }
+
+    double min_distance = HUGE;
+    int dx = 0;
+    int dy = 0;
+    int i;
+
+    std::vector<MonitorInfo>& monitors = (*qury)->get_monitors();
+    std::vector<MonitorInfo>::iterator iter = monitors.begin();
+    for (; iter != monitors.end(); iter++) {
+        double distance = sqrt(pow((double)(*iter).position.x, 2) + pow((double)(*iter).position.y,
+                                                                        2));
+        if (distance < min_distance) {
+            min_distance = distance;
+            dx = -(*iter).position.x;
+            dy = -(*iter).position.y;
+        }
+    }
+
+    Message* message = new Message(REDC_AGENT_DATA,sizeof(VDAgentMessage) +
+                                   sizeof(VDAgentMonitorsConfig) +
+                                   monitors.size() * sizeof(VDAgentMonConfig));
+    VDAgentMessage* msg = (VDAgentMessage*)message->data();
+    msg->protocol = VD_AGENT_PROTOCOL;
+    msg->type = VD_AGENT_MONITORS_CONFIG;
+    msg->opaque = 0;
+    msg->size = sizeof(VDAgentMonitorsConfig) + monitors.size() * sizeof(VDAgentMonConfig);
+
+    VDAgentMonitorsConfig* mon_config = (VDAgentMonitorsConfig*)msg->data;
+    mon_config->num_of_monitors = monitors.size();
+    mon_config->flags = 0;
+    if (Platform::is_monitors_pos_valid()) {
+        mon_config->flags = VD_AGENT_CONFIG_MONITORS_FLAG_USE_POS;
+    }
+    for (iter = monitors.begin(), i = 0; iter != monitors.end(); iter++, i++) {
+        mon_config->monitors[i].depth = (*iter).depth;
+        mon_config->monitors[i].width = (*iter).size.x;
+        mon_config->monitors[i].height = (*iter).size.y;
+        mon_config->monitors[i].x = (*iter).position.x + dx;
+        mon_config->monitors[i].y = (*iter).position.y + dy;
+    }
+    ASSERT(_agent_tokens)
+    _agent_tokens--;
+    post_message(message);
+    _agent_mon_config_sent = true;
+}
+
+#define MIN_DISPLAY_PIXMAP_CACHE (1024 * 1024 * 20)
+#define MAX_DISPLAY_PIXMAP_CACHE (1024 * 1024 * 80)
+#define MIN_MEM_FOR_OTHERS (1024 * 1024 * 40)
+
+// tmp till the pci mem will be shared by the qxls
+#define MIN_GLZ_WINDOW_SIZE (1024 * 1024 * 12)
+#define MAX_GLZ_WINDOW_SIZE MIN((LZ_MAX_WINDOW_SIZE * 4), 1024 * 1024 * 64)
+
+void RedClient::calc_pixmap_cach_and_glz_window_size(uint32_t display_channels_hint,
+                                                     uint32_t pci_mem_hint)
+{
+#ifdef WIN32
+    display_channels_hint = MAX(1, display_channels_hint);
+    int max_cache_size = display_channels_hint * MAX_DISPLAY_PIXMAP_CACHE;
+    int min_cache_size = display_channels_hint * MIN_DISPLAY_PIXMAP_CACHE;
+
+    MEMORYSTATUSEX mem_status;
+    mem_status.dwLength = sizeof(mem_status);
+
+    if (!GlobalMemoryStatusEx(&mem_status)) {
+        THROW("get mem status failed %u", GetLastError());
+    }
+
+    //ullTotalPageFile is physical memory plus the size of the page file, minus a small overhead
+    uint64_t free_mem = mem_status.ullAvailPageFile;
+    if (free_mem < (min_cache_size + MIN_MEM_FOR_OTHERS + MIN_GLZ_WINDOW_SIZE)) {
+        THROW_ERR(SPICEC_ERROR_CODE_NOT_ENOUGH_MEMORY, "low memory condition");
+    }
+    free_mem -= MIN_MEM_FOR_OTHERS;
+    _glz_window_size = MIN(MAX_GLZ_WINDOW_SIZE, pci_mem_hint / 2);
+    _glz_window_size = (int)MIN(free_mem / 3, _glz_window_size);
+    _glz_window_size = MAX(MIN_GLZ_WINDOW_SIZE, _glz_window_size);
+    free_mem -= _glz_window_size;
+    _pixmap_cache_size = MIN(free_mem, mem_status.ullAvailVirtual);
+    _pixmap_cache_size = MIN(free_mem, max_cache_size);
+#else
+    //for now
+    _glz_window_size = (int)MIN(MAX_GLZ_WINDOW_SIZE, pci_mem_hint / 2);
+    _glz_window_size = MAX(MIN_GLZ_WINDOW_SIZE, _glz_window_size);
+    _pixmap_cache_size = MAX_DISPLAY_PIXMAP_CACHE;
+#endif
+
+    _pixmap_cache_size /= 4;
+    _glz_window_size /= 4;
+}
+
+void RedClient::on_display_mode_change()
+{
+#ifdef USE_OGL
+    Lock lock(_channels_lock);
+    Channels::iterator iter = _channels.begin();
+    for (; iter != _channels.end(); ++iter) {
+        if ((*iter)->get_type() == RED_CHANNEL_DISPLAY) {
+            ((DisplayChannel *)(*iter))->recreate_ogl_context();
+        }
+    }
+#endif
+}
+
+void RedClient::set_mouse_mode(uint32_t supported_modes, uint32_t current_mode)
+{
+    if (current_mode != _mouse_mode) {
+        _mouse_mode = current_mode;
+        Lock lock(_channels_lock);
+        Channels::iterator iter = _channels.begin();
+        for (; iter != _channels.end(); ++iter) {
+            if ((*iter)->get_type() == RED_CHANNEL_CURSOR) {
+                ((CursorChannel *)(*iter))->set_cursor_mode();
+            }
+        }
+    }
+    // FIXME: use configured mouse mode (currently, use client mouse mode if supported by server)
+    if ((supported_modes & RED_MOUSE_MODE_CLIENT) && (current_mode != RED_MOUSE_MODE_CLIENT)) {
+        Message* message = new Message(REDC_MOUSE_MODE_REQUEST, sizeof(RedcMouseModeRequest));
+        RedcMouseModeRequest* mouse_mode_request = (RedcMouseModeRequest*)message->data();
+        mouse_mode_request->mode = RED_MOUSE_MODE_CLIENT;
+        post_message(message);
+    }
+}
+
+void RedClient::handle_init(RedPeer::InMessage* message)
+{
+    RedInit *init = (RedInit *)message->data();
+    _connection_id = init->session_id;
+    set_mm_time(init->multi_media_time);
+    calc_pixmap_cach_and_glz_window_size(init->display_channels_hint, init->ram_hint);
+    _glz_window.set_pixels_capacity(_glz_window_size);
+    set_mouse_mode(init->supported_mouse_modes, init->current_mouse_mode);
+    _agent_tokens = init->agent_tokens;
+    _agent_connected = !!init->agent_connected;
+    if (_agent_connected) {
+        Message* msg = new Message(REDC_AGENT_START, sizeof(RedcAgentStart));
+        RedcAgentStart* agent_start = (RedcAgentStart *)msg->data();
+        agent_start->num_tokens = ~0;
+        post_message(msg);
+    }
+    if (_auto_display_res) {
+        Platform::activate_interval_timer(_agent_timer, AGENT_TIMEOUT);
+        if (_agent_connected) {
+            send_agent_monitors_config();
+        }
+    } else {
+        post_message(new Message(REDC_ATTACH_CHANNELS, 0));
+    }
+}
+
+void RedClient::handle_channels(RedPeer::InMessage* message)
+{
+    RedChannels *init = (RedChannels *)message->data();
+    RedChannelInit* channels = init->channels;
+    for (unsigned int i = 0; i < init->num_of_channels; i++) {
+        create_channel(channels[i].type, channels[i].id);
+    }
+}
+
+void RedClient::handle_mouse_mode(RedPeer::InMessage* message)
+{
+    RedMouseMode *mouse_mode = (RedMouseMode *)message->data();
+    set_mouse_mode(mouse_mode->supported_modes, mouse_mode->current_mode);
+}
+
+void RedClient::handle_mm_time(RedPeer::InMessage* message)
+{
+    RedMultiMediaTime *mm_time = (RedMultiMediaTime *)message->data();
+    set_mm_time(mm_time->time);
+}
+
+void RedClient::handle_agent_connected(RedPeer::InMessage* message)
+{
+    DBG(0, "");
+    _agent_connected = true;
+    Message* msg = new Message(REDC_AGENT_START, sizeof(RedcAgentStart));
+    RedcAgentStart* agent_start = (RedcAgentStart *)msg->data();
+    agent_start->num_tokens = ~0;
+    post_message(msg);
+    if (_auto_display_res && !_agent_mon_config_sent) {
+        send_agent_monitors_config();
+    }
+}
+
+void RedClient::handle_agent_disconnected(RedPeer::InMessage* message)
+{
+    DBG(0, "");
+    _agent_connected = false;
+}
+
+void RedClient::on_agent_reply(VDAgentReply* reply)
+{
+    switch (reply->error) {
+    case VD_AGENT_SUCCESS:
+        break;
+    case VD_AGENT_ERROR:
+        THROW_ERR(SPICEC_ERROR_CODE_AGENT_ERROR, "vdagent error");
+    default:
+        THROW("unknown vdagent error");
+    }
+    switch (reply->type) {
+    case VD_AGENT_MONITORS_CONFIG:
+        post_message(new Message(REDC_ATTACH_CHANNELS, 0));
+        Platform::deactivate_interval_timer(_agent_timer);
+        break;
+    default:
+        THROW("unexpected vdagent reply type");
+    }
+}
+
+void RedClient::handle_agent_data(RedPeer::InMessage* message)
+{
+    uint32_t msg_size = message->size();
+    uint8_t* msg_pos = message->data();
+    uint32_t n;
+
+    DBG(0, "");
+    while (msg_size) {
+        if (_agent_msg_pos < sizeof(VDAgentMessage)) {
+            n = MIN(sizeof(VDAgentMessage) - _agent_msg_pos, msg_size);
+            memcpy((uint8_t*)_agent_msg + _agent_msg_pos, msg_pos, n);
+            _agent_msg_pos += n;
+            msg_size -= n;
+            msg_pos += n;
+            if (_agent_msg_pos == sizeof(VDAgentMessage)) {
+                if (_agent_msg->protocol != VD_AGENT_PROTOCOL) {
+                    THROW("Invalid protocol %u", _agent_msg->protocol);
+                }
+                _agent_msg_data = new uint8_t[_agent_msg->size];
+            }
+        }
+        if (_agent_msg_pos >= sizeof(VDAgentMessage)) {
+            n = MIN(sizeof(VDAgentMessage) + _agent_msg->size - _agent_msg_pos, msg_size);
+            memcpy(_agent_msg_data + _agent_msg_pos - sizeof(VDAgentMessage), msg_pos, n);
+            _agent_msg_pos += n;
+            msg_size -= n;
+            msg_pos += n;
+        }
+        if (_agent_msg_pos == sizeof(VDAgentMessage) + _agent_msg->size) {
+            switch (_agent_msg->type) {
+            case VD_AGENT_REPLY: {
+                on_agent_reply((VDAgentReply*)_agent_msg_data);
+                break;
+            }
+            default:
+                DBG(0, "Unsupported message type %u size %u", _agent_msg->type, _agent_msg->size);
+            }
+            delete[] _agent_msg_data;
+            _agent_msg_data = NULL;
+            _agent_msg_pos = 0;
+        }
+    }
+}
+
+void RedClient::handle_agent_tokens(RedPeer::InMessage* message)
+{
+    RedAgentTokens *token = (RedAgentTokens *)message->data();
+    _agent_tokens += token->num_tokens;
+}
+
+void RedClient::migrate_channel(RedChannel& channel)
+{
+    DBG(0, "channel type %u id %u", channel.get_type(), channel.get_id());
+    _migrate.swap_peer(channel);
+}
+
+void RedClient::get_sync_info(uint8_t channel_type, uint8_t channel_id, SyncInfo& info)
+{
+    info.lock = &_sync_lock;
+    info.condition = &_sync_condition;
+    info.message_serial = &_sync_info[channel_type][channel_id];
+}
+
+void RedClient::wait_for_channels(int wait_list_size, RedWaitForChannel* wait_list)
+{
+    for (int i = 0; i < wait_list_size; i++) {
+        if (wait_list[i].channel_type >= RED_CHANNEL_END) {
+            THROW("invalid channel type %u", wait_list[i].channel_type);
+        }
+        uint64_t& sync_cell = _sync_info[wait_list[i].channel_type][wait_list[i].channel_id];
+#ifndef RED64
+        Lock lock(_sync_lock);
+#endif
+        if (sync_cell >= wait_list[i].message_serial) {
+            continue;
+        }
+#ifdef RED64
+        Lock lock(_sync_lock);
+#endif
+        for (;;) {
+            if (sync_cell >= wait_list[i].message_serial) {
+                break;
+            }
+            if (_aborting) {
+                THROW("aborting");
+            }
+            _sync_condition.wait(lock);
+            continue;
+        }
+    }
+}
+
+void RedClient::set_mm_time(uint32_t time)
+{
+    Lock lock(_mm_clock_lock);
+    _mm_clock_last_update = Platform::get_monolithic_time();
+    _mm_time = time;
+}
+
+uint32_t RedClient::get_mm_time()
+{
+    Lock lock(_mm_clock_lock);
+    return uint32_t((Platform::get_monolithic_time() - _mm_clock_last_update) / 1000 / 1000 +
+                    _mm_time);
+}
+
+void RedClient::register_channel_factory(ChannelFactory& factory)
+{
+    _factorys.push_back(&factory);
+}
+
diff --git a/client/red_client.h b/client/red_client.h
new file mode 100644
index 00000000..d799e788
--- /dev/null
+++ b/client/red_client.h
@@ -0,0 +1,234 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REDCLIENT
+#define _H_REDCLIENT
+
+#include <list>
+
+#include "common.h"
+#include "red_peer.h"
+#include "red_channel.h"
+#include "display_channel.h"
+#include "inputs_channel.h"
+#include "cursor_channel.h"
+#include "audio_channels.h"
+#include "red.h"
+#include "vd_agent.h"
+
+class Application;
+class Event;
+
+class MigChannel: public RedChannelBase {
+public:
+    MigChannel(uint32_t type, uint32_t id, const ChannelCaps& common_caps, const ChannelCaps& caps)
+        : RedChannelBase(type, id, common_caps, caps)
+        , _valid(false) {}
+    bool is_valid() { return _valid;}
+    void set_valid(bool val) { _valid = val;}
+
+private:
+    bool _valid;
+};
+
+class Migrate {
+public:
+    Migrate(RedClient& client);
+    ~Migrate();
+
+    void start(const RedMigrationBegin* migrate);
+    bool abort();
+    void add_channel(MigChannel* channel);
+    void clear_channels();
+    void swap_peer(RedChannelBase& other);
+
+private:
+    void connect_one(MigChannel& channel, const RedPeer::ConnectionOptions& options,
+                     uint32_t connection_id);
+    void disconnect_channels();
+    void close_channels();
+    void delete_channels();
+    void run();
+    static void* worker_main(void *data);
+
+private:
+    RedClient& _client;
+    typedef std::list<MigChannel*> MigChannels;
+    MigChannels _channels;
+    bool _running;
+    bool _aborting;
+    bool _connected;
+    std::string _password;
+    std::string _host;
+    int _port;
+    int _sport;
+    Thread* _thread;
+    Mutex _lock;
+    Condition _cond;
+    int _pending_con;
+};
+
+class ChannelFactory {
+public:
+    ChannelFactory(uint32_t type) : _type (type) {}
+    virtual ~ChannelFactory() {}
+
+    uint32_t type() { return _type;}
+    virtual RedChannel* construct(RedClient& client, uint32_t id) = 0;
+
+private:
+    uint32_t _type;
+};
+
+class GlzDecoderWindowDebug: public GlzDecoderDebug {
+public:
+    virtual void error(const std::string& str)
+    {
+        throw Exception(str);
+    }
+
+    virtual void warn(const std::string& str)
+    {
+        LOG_WARN("%s", str.c_str());
+    }
+
+    virtual void info(const std::string& str)
+    {
+        LOG_INFO("%s", str.c_str());
+    }
+};
+
+typedef std::map< int, RedPeer::ConnectionOptions::Type> PeerConnectionOptMap;
+
+class RedClient: public RedChannel {
+public:
+    friend class RedChannel;
+    friend class Migrate;
+
+    RedClient(Application& application);
+    ~RedClient();
+
+    void init(const char* host, int port, int sport, const char *password, bool auto_display_res);
+
+    void register_channel_factory(ChannelFactory& factory);
+
+    virtual void connect();
+    virtual void disconnect();
+    virtual bool abort();
+
+    void push_event(Event* event);
+
+    void set_target(const char* host, uint16_t port, uint16_t sport);
+    const char* get_password() { return _password.c_str();}
+    const char* get_host() { return _host.c_str();}
+    int get_port() { return _port;}
+    int get_sport() { return _sport;}
+    virtual uint32_t get_connection_id() { return _connection_id;}
+    uint32_t get_mouse_mode() { return _mouse_mode;}
+    Application& get_application() { return _application;}
+    bool is_auto_display_res() { return _auto_display_res;}
+    RedPeer::ConnectionOptions::Type get_connection_options(uint32_t channel_type);
+    void get_sync_info(uint8_t channel_type, uint8_t channel_id, SyncInfo& info);
+    void wait_for_channels(int wait_list_size, RedWaitForChannel* wait_list);
+    PixmapCache& get_pixmap_cache() {return _pixmap_cache;}
+    uint64_t get_pixmap_cache_size() { return _pixmap_cache_size;}
+    void on_display_mode_change();
+
+    GlzDecoderWindow& get_glz_window() {return _glz_window;}
+    int get_glz_window_size() { return _glz_window_size;}
+
+    void set_mm_time(uint32_t time);
+    uint32_t get_mm_time();
+
+protected:
+    virtual void on_connecting();
+    virtual void on_connect();
+    virtual void on_disconnect();
+
+private:
+    void on_channel_disconnected(RedChannel& channel);
+    void migrate_channel(RedChannel& channel);
+    void send_agent_monitors_config();
+    void calc_pixmap_cach_and_glz_window_size(uint32_t display_channels_hint,
+                                              uint32_t pci_mem_hint);
+    void set_mouse_mode(uint32_t supported_modes, uint32_t current_mode);
+
+    void handle_migrate_begin(RedPeer::InMessage* message);
+    void handle_migrate_cancel(RedPeer::InMessage* message);
+    void handle_init(RedPeer::InMessage* message);
+    void handle_channels(RedPeer::InMessage* message);
+    void handle_mouse_mode(RedPeer::InMessage* message);
+    void handle_mm_time(RedPeer::InMessage* message);
+    void handle_agent_connected(RedPeer::InMessage* message);
+    void handle_agent_disconnected(RedPeer::InMessage* message);
+    void handle_agent_data(RedPeer::InMessage* message);
+    void handle_agent_tokens(RedPeer::InMessage* message);
+
+    void on_agent_reply(VDAgentReply* reply);
+
+    ChannelFactory* find_factory(uint32_t type);
+    void create_channel(uint32_t type, uint32_t id);
+    void disconnect_channels();
+    void delete_channels();
+    bool abort_channels();
+
+private:
+    Application& _application;
+
+    std::string _password;
+    std::string _host;
+    int _port;
+    int _sport;
+    uint32_t _connection_id;
+    uint32_t _mouse_mode;
+    Mutex _notify_lock;
+    bool _notify_disconnect;
+    bool _auto_display_res;
+    bool _aborting;
+
+    bool _agent_connected;
+    bool _agent_mon_config_sent;
+    VDAgentMessage* _agent_msg;
+    uint8_t* _agent_msg_data;
+    uint32_t _agent_msg_pos;
+    uint32_t _agent_tokens;
+    TimerID _agent_timer;
+
+    PeerConnectionOptMap _con_opt_map;
+    Migrate _migrate;
+    Mutex _channels_lock;
+    typedef std::list<ChannelFactory*> Factorys;
+    Factorys _factorys;
+    typedef std::list<RedChannel*> Channels;
+    Channels _channels;
+    PixmapCache _pixmap_cache;
+    uint64_t _pixmap_cache_size;
+    Mutex _sync_lock;
+    Condition _sync_condition;
+    uint64_t _sync_info[RED_CHANNEL_END][256];
+
+    GlzDecoderWindowDebug _glz_debug;
+    GlzDecoderWindow _glz_window;
+    int _glz_window_size; // in pixels
+
+    Mutex _mm_clock_lock;
+    uint64_t _mm_clock_last_update;
+    uint32_t _mm_time;
+};
+
+#endif
+
diff --git a/client/red_drawable.h b/client/red_drawable.h
new file mode 100644
index 00000000..eae2e0dd
--- /dev/null
+++ b/client/red_drawable.h
@@ -0,0 +1,66 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_DRAWABLE
+#define _H_RED_DRAWABLE
+
+#include "pixels_source.h"
+
+typedef uint32_t rgb32_t;
+
+static inline rgb32_t rgb32_make(uint8_t r, uint8_t g, uint8_t b)
+{
+    return (rgb32_t(r) << 16) | (rgb32_t(g) << 8) | b;
+}
+
+static inline uint8_t rgb32_get_red(rgb32_t color)
+{
+    return color >> 16;
+}
+
+static inline uint8_t rgb32_get_green(rgb32_t color)
+{
+    return color >> 8;
+}
+
+static inline uint8_t rgb32_get_blue(rgb32_t color)
+{
+    return color;
+}
+
+class RedDrawable: public PixelsSource {
+public:
+    RedDrawable() {}
+    virtual ~RedDrawable() {}
+
+    enum CombineOP {
+        OP_COPY,
+        OP_AND,
+        OP_XOR,
+    };
+
+    void copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest);
+    void blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest);
+    void combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest,
+                        CombineOP op);
+    void fill_rect(const Rect& rect, rgb32_t color);
+    void frame_rect(const Rect& rect, rgb32_t color);
+    void erase_rect(const Rect& rect, rgb32_t color);
+};
+
+#endif
+
diff --git a/client/red_gdi_canvas.cpp b/client/red_gdi_canvas.cpp
new file mode 100644
index 00000000..809468fc
--- /dev/null
+++ b/client/red_gdi_canvas.cpp
@@ -0,0 +1,174 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <stdint.h>
+#include "red_gdi_canvas.h"
+#include "utils.h"
+#include "debug.h"
+#include "region.h"
+#include "red_pixmap_gdi.h"
+
+GDICanvas::GDICanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+                     GlzDecoderWindow &glz_decoder_window)
+    : Canvas (pixmap_cache, palette_cache, glz_decoder_window)
+    , _canvas (NULL)
+    , _pixmap (0)
+{
+}
+
+GDICanvas::~GDICanvas()
+{
+    destroy();
+}
+
+void GDICanvas::destroy()
+{
+    if (_canvas) {
+        _canvas = NULL;
+    }
+    destroy_pixmap();
+}
+
+void GDICanvas::clear()
+{
+    if (_canvas) {
+        gdi_canvas_clear(_canvas);
+    }
+}
+
+void GDICanvas::destroy_pixmap()
+{
+    delete _pixmap;
+    _pixmap = NULL;
+}
+
+void GDICanvas::create_pixmap(int width, int height)
+{
+    _pixmap = new RedPixmapGdi(width, height, RedPixmap::RGB32, true, NULL);
+}
+
+void GDICanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
+{
+    for (int i = 0; i < (int)region.num_rects; i++) {
+        Rect* r = &region.rects[i];
+        dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
+    }
+}
+
+void GDICanvas::copy_pixels(const QRegion& region, RedDrawable* dest_dc, const PixmapHeader* pixmap)
+{
+    copy_pixels(region, *dest_dc);
+}
+
+void GDICanvas::set_mode(int width, int height, int depth)
+{
+    destroy();
+    create_pixmap(width, height);
+    if (!(_canvas = gdi_canvas_create(_pixmap->get_dc(),
+                                      &_pixmap->get_mutex(),
+                                      depth, &pixmap_cache(), bits_cache_put,
+                                      bits_cache_get, &palette_cache(),
+                                      palette_cache_put, palette_cache_get,
+                                      palette_cache_release,
+                                      &glz_decoder(),
+                                      glz_decode))) {
+        THROW("create canvas failed");
+    }
+}
+
+void GDICanvas::set_access_params(ADDRESS delta, unsigned long base, unsigned long max)
+{
+    gdi_canvas_set_access_params(_canvas, delta, base, max);
+}
+
+void GDICanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+{
+    gdi_canvas_draw_fill(_canvas, bbox, clip, fill);
+}
+
+void GDICanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+{
+    gdi_canvas_draw_text(_canvas, bbox, clip, text);
+}
+
+void GDICanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    gdi_canvas_draw_opaque(_canvas, bbox, clip, opaque);
+}
+
+void GDICanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+{
+    gdi_canvas_draw_copy(_canvas, bbox, clip, copy);
+}
+
+void GDICanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+{
+    gdi_canvas_draw_transparent(_canvas, bbox, clip, transparent);
+}
+
+void GDICanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+    gdi_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
+}
+
+void GDICanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+{
+    gdi_canvas_copy_bits(_canvas, bbox, clip, src_pos);
+}
+
+void GDICanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+{
+    gdi_canvas_draw_blend(_canvas, bbox, clip, blend);
+}
+
+void GDICanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    gdi_canvas_draw_blackness(_canvas, bbox, clip, blackness);
+}
+
+void GDICanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    gdi_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
+}
+
+void GDICanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+{
+    gdi_canvas_draw_invers(_canvas, bbox, clip, invers);
+}
+
+void GDICanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    gdi_canvas_draw_rop3(_canvas, bbox, clip, rop3);
+}
+
+void GDICanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    gdi_canvas_draw_stroke(_canvas, bbox, clip, stroke);
+}
+
+void GDICanvas::put_image(HDC dc, const PixmapHeader& image, const Rect& dest, const QRegion* clip)
+{
+    gdi_canvas_put_image(_canvas, dc, &dest, image.data, image.width, image.height, image.stride,
+                         clip);
+}
+
+CanvasType GDICanvas::get_pixmap_type()
+{
+    return CANVAS_TYPE_GDI;
+}
+
diff --git a/client/red_gdi_canvas.h b/client/red_gdi_canvas.h
new file mode 100644
index 00000000..c62fed67
--- /dev/null
+++ b/client/red_gdi_canvas.h
@@ -0,0 +1,77 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GDICANVAS
+#define _H_GDICANVAS
+
+#include "canvas.h"
+#include "gdi_canvas.h"
+#include "red_pixmap_gdi.h"
+
+class RedPixmap;
+
+
+class GDICanvas: public Canvas {
+public:
+    GDICanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+              GlzDecoderWindow &glz_decoder_window);
+    virtual ~GDICanvas();
+
+    virtual void set_mode(int x, int y, int bits);
+    virtual void clear();
+    virtual void thread_touch() {}
+    virtual void copy_pixels(const QRegion& region, RedDrawable* dc,
+                             const PixmapHeader* pixmap);
+    virtual void copy_pixels(const QRegion& region, RedDrawable& dc);
+    virtual void put_image(HDC dc, const PixmapHeader& image, const Rect& dest,
+                           const QRegion* clip);
+
+    virtual CanvasType get_pixmap_type();
+
+protected:
+    virtual void set_access_params(ADDRESS delta, unsigned long base, unsigned long max);
+    virtual void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
+    virtual void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
+    virtual void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
+    virtual void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
+    virtual void draw_text(Rect *bbox, Clip *clip, Text *text);
+    virtual void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
+    virtual void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
+    virtual void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
+    virtual void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
+    virtual void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
+    virtual void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
+    virtual void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
+    virtual void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+
+private:
+    void create_pixmap(int width, int height);
+    void destroy_pixmap();
+    void destroy();
+
+private:
+    GdiCanvas* _canvas;
+    RedPixmapGdi *_pixmap;
+    RedPixmapGdi *_helper_pixmap;
+    HDC _dc;
+    HBITMAP _prev_bitmap;
+    unsigned long _base;
+    unsigned long _max;
+};
+
+#endif
+
diff --git a/client/red_gl_canvas.cpp b/client/red_gl_canvas.cpp
new file mode 100644
index 00000000..168734ca
--- /dev/null
+++ b/client/red_gl_canvas.cpp
@@ -0,0 +1,219 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <stdint.h>
+#include "red_gl_canvas.h"
+#include "utils.h"
+#include "debug.h"
+#include "region.h"
+#include "red_pixmap_gl.h"
+#include <GL/glx.h>
+
+GCanvas::GCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+                 GlzDecoderWindow &glz_decoder_window)
+    : Canvas(pixmap_cache, palette_cache, glz_decoder_window)
+    , _canvas (NULL)
+    , _pixmap (0)
+    , _textures_lost (false)
+{
+}
+
+GCanvas::~GCanvas()
+{
+    destroy();
+}
+
+void GCanvas::destroy()
+{
+    if (_canvas) {
+        gl_canvas_destroy(_canvas, _textures_lost);
+        _canvas = NULL;
+    }
+    destroy_pixmap();
+}
+
+void GCanvas::clear()
+{
+    if (_canvas) {
+        gl_canvas_clear(_canvas);
+    }
+}
+
+void GCanvas::destroy_pixmap()
+{
+    delete _pixmap;
+    _pixmap = NULL;
+}
+
+void GCanvas::create_pixmap(int width, int height, RedWindow *win,
+                            RenderType rendertype)
+{
+    _pixmap = new RedPixmapGL(width, height, RedPixmap::RGB32, true, NULL,
+                              win, rendertype);
+}
+
+void GCanvas::copy_pixels(const QRegion& region, RedDrawable& dest_dc)
+{
+    for (int i = 0; i < (int)region.num_rects; i++) {
+        Rect* r = &region.rects[i];
+        dest_dc.copy_pixels(*_pixmap, r->left, r->top, *r);
+    }
+}
+
+void GCanvas::copy_pixels(const QRegion& region, RedDrawable* dest_dc, const PixmapHeader* pixmap)
+{
+    copy_pixels(region, *dest_dc);
+}
+
+void GCanvas::set_mode(int width, int height, int depth, RedWindow *win,
+                       RenderType rendertype)
+{
+    destroy();
+
+    create_pixmap(width, height, win, rendertype);
+    if (!(_canvas = gl_canvas_create(NULL, width, height, depth,
+                                     &pixmap_cache(),
+                                     bits_cache_put,
+                                     bits_cache_get,
+                                     &palette_cache(),
+                                     palette_cache_put,
+                                     palette_cache_get,
+                                     palette_cache_release,
+                                     &glz_decoder(),
+                                     glz_decode))) {
+        THROW("create canvas failed");
+    }
+}
+
+void GCanvas::set_access_params(ADDRESS delta, unsigned long base, unsigned long max)
+{
+    gl_canvas_set_access_params(_canvas, delta, base, max);
+}
+
+void GCanvas::draw_fill(Rect *bbox, Clip *clip, Fill *fill)
+{
+    gl_canvas_draw_fill(_canvas, bbox, clip, fill);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_text(Rect *bbox, Clip *clip, Text *text)
+{
+    gl_canvas_draw_text(_canvas, bbox, clip, text);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    gl_canvas_draw_opaque(_canvas, bbox, clip, opaque);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_copy(Rect *bbox, Clip *clip, Copy *copy)
+{
+    gl_canvas_draw_copy(_canvas, bbox, clip, copy);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent)
+{
+    gl_canvas_draw_transparent(_canvas, bbox, clip, transparent);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+    gl_canvas_draw_alpha_blend(_canvas, bbox, clip, alpha_blend);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::copy_bits(Rect *bbox, Clip *clip, Point *src_pos)
+{
+    gl_canvas_copy_pixels(_canvas, bbox, clip, src_pos);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_blend(Rect *bbox, Clip *clip, Blend *blend)
+{
+    gl_canvas_draw_blend(_canvas, bbox, clip, blend);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    gl_canvas_draw_blackness(_canvas, bbox, clip, blackness);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    gl_canvas_draw_whiteness(_canvas, bbox, clip, whiteness);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_invers(Rect *bbox, Clip *clip, Invers *invers)
+{
+    gl_canvas_draw_invers(_canvas, bbox, clip, invers);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    gl_canvas_draw_rop3(_canvas, bbox, clip, rop3);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    gl_canvas_draw_stroke(_canvas, bbox, clip, stroke);
+    _pixmap->update_texture(bbox);
+}
+
+void GCanvas::put_image(const PixmapHeader& image, const Rect& dest,
+                        const QRegion* clip)
+{
+    gl_canvas_put_image(_canvas, &dest, image.data, image.width, image.height,
+                        image.stride, clip);
+    _pixmap->update_texture(&dest);
+}
+
+CanvasType GCanvas::get_pixmap_type()
+{
+    return CANVAS_TYPE_GL;
+}
+
+void GCanvas::textures_lost()
+{
+    _textures_lost = true;
+    _pixmap->textures_lost();
+}
+
+void GCanvas::touch_context()
+{
+    _pixmap->touch_context();
+}
+
+void GCanvas::pre_gl_copy()
+{
+    _pixmap->pre_copy();
+}
+
+void GCanvas::post_gl_copy()
+{
+    _pixmap->past_copy();
+}
+
diff --git a/client/red_gl_canvas.h b/client/red_gl_canvas.h
new file mode 100644
index 00000000..4bf8542e
--- /dev/null
+++ b/client/red_gl_canvas.h
@@ -0,0 +1,79 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GCANVAS
+#define _H_GCANVAS
+
+#include "canvas.h"
+#include "cairo_canvas.h"
+#include "gl_canvas.h"
+#include "red_pixmap_gl.h"
+#include "red_window.h"
+
+class RedPixmapGL;
+
+class GCanvas: public Canvas {
+public:
+    GCanvas(PixmapCache& pixmap_cache, PaletteCache& palette_cache,
+            GlzDecoderWindow &glz_decoder_window);
+    virtual ~GCanvas();
+
+    void set_mode(int width, int height, int depth, RedWindow *win,
+                  RenderType rendertype);
+    void clear();
+    void thread_touch() {}
+    void copy_pixels(const QRegion& region, RedDrawable* dc,
+                     const PixmapHeader* pixmap);
+    void copy_pixels(const QRegion& region, RedDrawable& dc);
+    void put_image(const PixmapHeader& image, const Rect& dest,
+                   const QRegion* clip);
+
+    void set_access_params(ADDRESS delta, unsigned long base, unsigned long max);
+    void draw_fill(Rect *bbox, Clip *clip, Fill *fill);
+    void draw_copy(Rect *bbox, Clip *clip, Copy *copy);
+    void draw_opaque(Rect *bbox, Clip *clip, Opaque *opaque);
+    void copy_bits(Rect *bbox, Clip *clip, Point *src_pos);
+    void draw_text(Rect *bbox, Clip *clip, Text *text);
+    void draw_stroke(Rect *bbox, Clip *clip, Stroke *stroke);
+    void draw_rop3(Rect *bbox, Clip *clip, Rop3 *rop3);
+    void draw_blend(Rect *bbox, Clip *clip, Blend *blend);
+    void draw_blackness(Rect *bbox, Clip *clip, Blackness *blackness);
+    void draw_whiteness(Rect *bbox, Clip *clip, Whiteness *whiteness);
+    void draw_invers(Rect *bbox, Clip *clip, Invers *invers);
+    void draw_transparent(Rect *bbox, Clip *clip, Transparent* transparent);
+    void draw_alpha_blend(Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+
+    virtual void textures_lost();
+    virtual CanvasType get_pixmap_type();
+    virtual void touch_context();
+    virtual void pre_gl_copy();
+    virtual void post_gl_copy();
+
+private:
+    void create_pixmap(int width, int height, RedWindow *win,
+                       RenderType rendertype);
+    void destroy_pixmap();
+    void destroy();
+
+private:
+    GLCanvas* _canvas;
+    RedPixmapGL *_pixmap;
+    bool _textures_lost;
+};
+
+#endif
+
diff --git a/client/red_key.h b/client/red_key.h
new file mode 100644
index 00000000..70a4b731
--- /dev/null
+++ b/client/red_key.h
@@ -0,0 +1,150 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_KEY
+#define _H_RED_KEY
+
+enum RedKey {
+    REDKEY_INVALID,
+    REDKEY_ESCAPE,
+    REDKEY_1,
+    REDKEY_2,
+    REDKEY_3,
+    REDKEY_4,
+    REDKEY_5,
+    REDKEY_6,
+    REDKEY_7,
+    REDKEY_8,
+    REDKEY_9,
+    REDKEY_0,
+    REDKEY_MINUS,
+    REDKEY_EQUALS,
+    REDKEY_BACKSPACE,
+    REDKEY_TAB,
+    REDKEY_Q,
+    REDKEY_W,
+    REDKEY_E,
+    REDKEY_R,
+    REDKEY_T,
+    REDKEY_Y,
+    REDKEY_U,
+    REDKEY_I,
+    REDKEY_O,
+    REDKEY_P,
+    REDKEY_L_BRACKET,
+    REDKEY_R_BRACKET,
+    REDKEY_ENTER,
+    REDKEY_L_CTRL,
+    REDKEY_A,
+    REDKEY_S,
+    REDKEY_D,
+    REDKEY_F,
+    REDKEY_G,
+    REDKEY_H,
+    REDKEY_J,
+    REDKEY_K,
+    REDKEY_L,
+    REDKEY_SEMICOLON,
+    REDKEY_QUOTE,
+
+    REDKEY_BACK_QUOTE,
+    REDKEY_L_SHIFT,
+    REDKEY_BACK_SLASH,
+    REDKEY_Z,
+    REDKEY_X,
+    REDKEY_C,
+    REDKEY_V,
+    REDKEY_B,
+    REDKEY_N,
+    REDKEY_M,
+    REDKEY_COMMA,
+    REDKEY_PERIOD,
+    REDKEY_SLASH,
+    REDKEY_R_SHIFT,
+    REDKEY_PAD_MULTIPLY,
+    REDKEY_L_ALT,
+    REDKEY_SPACE,
+    REDKEY_CAPS_LOCK,
+    REDKEY_F1,
+    REDKEY_F2,
+    REDKEY_F3,
+    REDKEY_F4,
+    REDKEY_F5,
+    REDKEY_F6,
+    REDKEY_F7,
+    REDKEY_F8,
+    REDKEY_F9,
+    REDKEY_F10,
+    REDKEY_NUM_LOCK,
+    REDKEY_SCROLL_LOCK,
+    REDKEY_PAD_7,
+    REDKEY_PAD_8,
+    REDKEY_PAD_9,
+    REDKEY_PAD_MINUS,
+    REDKEY_PAD_4,
+    REDKEY_PAD_5,
+    REDKEY_PAD_6,
+    REDKEY_PAD_PLUS,
+    REDKEY_PAD_1,
+    REDKEY_PAD_2,
+    REDKEY_PAD_3,
+    REDKEY_PAD_0,
+    REDKEY_PAD_POINT,
+
+    REDKEY_EUROPEAN = 0x56,
+    REDKEY_F11,
+    REDKEY_F12,
+
+    REDKEY_JAPANESE_HIRAGANA_KATAKANA = 0x70,
+    REDKEY_JAPANESE_BACKSLASH = 0x73,
+    REDKEY_JAPANESE_HENKAN = 0x79,
+    REDKEY_JAPANESE_MUHENKAN = 0x7B,
+    REDKEY_JAPANESE_YEN = 0x7D,
+
+    REDKEY_KOREAN_HANGUL_HANJA = 0xf1,
+    REDKEY_KOREAN_HANGUL = 0xf2,
+
+    REDKEY_ESCAPE_BASE = 0x100,
+    REDKEY_PAD_ENTER = REDKEY_ESCAPE_BASE + 0x1c,
+    REDKEY_R_CTRL = REDKEY_ESCAPE_BASE + 0x1d,
+    REDKEY_FAKE_L_SHIFT = REDKEY_ESCAPE_BASE + 0x2a,
+    REDKEY_PAD_DIVIDE = REDKEY_ESCAPE_BASE + 0x35,
+    REDKEY_FAKE_R_SHIFT = REDKEY_ESCAPE_BASE + 0x36,
+    REDKEY_CTRL_PRINT_SCREEN = REDKEY_ESCAPE_BASE + 0x37,
+    REDKEY_R_ALT = REDKEY_ESCAPE_BASE + 0x38,
+    REDKEY_CTRL_BREAK = REDKEY_ESCAPE_BASE + 0x46,
+    REDKEY_HOME = REDKEY_ESCAPE_BASE + 0x47,
+    REDKEY_UP = REDKEY_ESCAPE_BASE + 0x48,
+    REDKEY_PAGEUP = REDKEY_ESCAPE_BASE + 0x49,
+    REDKEY_LEFT = REDKEY_ESCAPE_BASE + 0x4b,
+    REDKEY_RIGHT = REDKEY_ESCAPE_BASE + 0x4d,
+    REDKEY_END = REDKEY_ESCAPE_BASE + 0x4f,
+    REDKEY_DOWN = REDKEY_ESCAPE_BASE + 0x50,
+    REDKEY_PAGEDOWN = REDKEY_ESCAPE_BASE + 0x51,
+    REDKEY_INSERT = REDKEY_ESCAPE_BASE + 0x52,
+    REDKEY_DELETE = REDKEY_ESCAPE_BASE + 0x53,
+    REDKEY_LEFT_CMD = REDKEY_ESCAPE_BASE + 0x5b,
+    REDKEY_RIGHT_CMD = REDKEY_ESCAPE_BASE + 0x5c,
+    REDKEY_MENU = REDKEY_ESCAPE_BASE + 0x5d,
+
+    REDKEY_PAUSE,
+
+    REDKEY_NUM_KEYS
+};
+
+#endif
+
diff --git a/client/red_peer.cpp b/client/red_peer.cpp
new file mode 100644
index 00000000..e20d5ca6
--- /dev/null
+++ b/client/red_peer.cpp
@@ -0,0 +1,426 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+
+#define SHUT_RDWR SD_BOTH
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+#define closesocket(sock) ::close(sock)
+#endif
+#include "red.h"
+#include "red_peer.h"
+#include "utils.h"
+#include "debug.h"
+#include "platform_utils.h"
+
+#ifdef _WIN32
+
+int inet_aton(const char *ip, struct in_addr *in_addr)
+{
+    unsigned long addr = inet_addr(ip);
+
+    if (addr == INADDR_NONE) {
+        return 0;
+    }
+    in_addr->S_un.S_addr = addr;
+    return 1;
+}
+
+#define SHUTDOWN_ERR WSAESHUTDOWN
+#define INTERRUPTED_ERR WSAEINTR
+#define WOULDBLOCK_ERR WSAEWOULDBLOCK
+#define sock_error() WSAGetLastError()
+#define sock_err_message(err) sys_err_to_str(err)
+#else
+#define SHUTDOWN_ERR EPIPE
+#define INTERRUPTED_ERR EINTR
+#define WOULDBLOCK_ERR EAGAIN
+#define sock_error() errno
+#define sock_err_message(err) strerror(err)
+#endif
+
+static void ssl_error()
+{
+    ERR_print_errors_fp(stderr);
+    THROW_ERR(SPICEC_ERROR_CODE_SSL_ERROR, "SSL Error");
+}
+
+RedPeer::RedPeer()
+    : _peer (INVALID_SOCKET)
+    , _shut (false)
+    , _ctx (NULL)
+    , _ssl (NULL)
+{
+}
+
+RedPeer::~RedPeer()
+{
+    cleanup();
+}
+
+void RedPeer::cleanup()
+{
+    if (_ssl) {
+        SSL_free(_ssl);
+        _ssl = NULL;
+    }
+
+    if (_ctx) {
+        SSL_CTX_free(_ctx);
+        _ctx = NULL;
+    }
+
+    if (_peer != INVALID_SOCKET) {
+        closesocket(_peer);
+        _peer = INVALID_SOCKET;
+    }
+}
+
+uint32_t RedPeer::host_by_name(const char* host)
+{
+    struct addrinfo *result = NULL;
+    struct sockaddr_in *addr;
+    uint32_t return_value;
+    int rc;
+
+    rc = getaddrinfo(host, NULL, NULL, &result);
+    if (rc != 0 || result == NULL) {
+        THROW_ERR(SPICEC_ERROR_CODE_GETHOSTBYNAME_FAILED, "cannot resolve host address %s", host);
+    }
+
+    addr = (sockaddr_in *)result->ai_addr;
+    return_value = addr->sin_addr.s_addr;
+
+    freeaddrinfo(result);
+
+    DBG(0, "%s = %u", host, return_value);
+    return ntohl(return_value);
+}
+
+void RedPeer::connect_unsecure(uint32_t ip, int port)
+{
+    struct sockaddr_in addr;
+    int no_delay;
+
+    ASSERT(_ctx == NULL && _ssl == NULL && _peer == INVALID_SOCKET);
+    try {
+        addr.sin_port = htons(port);
+        addr.sin_family = AF_INET;
+        addr.sin_addr.s_addr = htonl(ip);
+
+        Lock lock(_lock);
+        if ((_peer = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
+            int err = sock_error();
+            THROW_ERR(SPICEC_ERROR_CODE_SOCKET_FAILED, "failed to create socket: %s (%d)",
+                      sock_err_message(err), err);
+        }
+
+        no_delay = 1;
+        if (setsockopt(_peer, IPPROTO_TCP, TCP_NODELAY, (const char*)&no_delay, sizeof(no_delay)) ==
+                                                                                     SOCKET_ERROR) {
+            LOG_WARN("set TCP_NODELAY failed");
+        }
+
+        LOG_INFO("Connecting %s %d", inet_ntoa(addr.sin_addr), port);
+        lock.unlock();
+        if (::connect(_peer, (struct sockaddr *)&addr, sizeof(sockaddr_in)) == SOCKET_ERROR) {
+            int err = sock_error();
+            closesocket(_peer);
+            THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "failed to connect: %s (%d)",
+                      sock_err_message(err), err);
+        }
+        _serial = 0;
+    } catch (...) {
+        Lock lock(_lock);
+        cleanup();
+        throw;
+    }
+}
+
+void RedPeer::connect_unsecure(const char* host, int port)
+{
+    connect_unsecure(host_by_name(host), port);
+}
+
+// todo: use SSL_CTX_set_cipher_list, SSL_CTX_load_verify_location etc.
+void RedPeer::connect_secure(const ConnectionOptions& options, uint32_t ip)
+{
+    connect_unsecure(ip, options.secure_port);
+    ASSERT(_ctx == NULL && _ssl == NULL && _peer != INVALID_SOCKET);
+
+    try {
+        SSL_METHOD *ssl_method = TLSv1_method();
+
+        _ctx = SSL_CTX_new(ssl_method);
+        if (_ctx == NULL) {
+            ssl_error();
+        }
+
+        _ssl = SSL_new(_ctx);
+        if (!_ssl) {
+            THROW("create ssl failed");
+        }
+
+        BIO* sbio = BIO_new_socket(_peer, BIO_NOCLOSE);
+        if (!sbio) {
+            THROW("alloc new socket bio failed");
+        }
+
+        SSL_set_bio(_ssl, sbio, sbio);
+
+        int return_code = SSL_connect(_ssl);
+        if (return_code <= 0) {
+            SSL_get_error(_ssl, return_code);
+            ssl_error();
+        }
+    } catch (...) {
+        Lock lock(_lock);
+        cleanup();
+        throw;
+    }
+}
+
+void RedPeer::connect_secure(const ConnectionOptions& options, const char* host)
+{
+    connect_secure(options, host_by_name(host));
+}
+
+void RedPeer::shutdown()
+{
+    if (_peer != INVALID_SOCKET) {
+        if (_ssl) {
+            SSL_shutdown(_ssl);
+        }
+        ::shutdown(_peer, SHUT_RDWR);
+    }
+    _shut = true;
+}
+
+void RedPeer::disconnect()
+{
+    Lock lock(_lock);
+    shutdown();
+}
+
+void RedPeer::close()
+{
+    Lock lock(_lock);
+    if (_peer != INVALID_SOCKET) {
+        if (_ctx) {
+            SSL_free(_ssl);
+            _ssl = NULL;
+            SSL_CTX_free(_ctx);
+            _ctx = NULL;
+        }
+
+        closesocket(_peer);
+        _peer = INVALID_SOCKET;
+    }
+}
+
+void RedPeer::swap(RedPeer* other)
+{
+    Lock lock(_lock);
+    SOCKET temp_peer = _peer;
+    SSL_CTX *temp_ctx = _ctx;
+    SSL *temp_ssl = _ssl;
+
+    _peer = other->_peer;
+    other->_peer = temp_peer;
+
+    if (_ctx) {
+        _ctx = other->_ctx;
+        _ssl = other->_ssl;
+
+        other->_ctx = temp_ctx;
+        other->_ssl = temp_ssl;
+    }
+
+    if (_shut) {
+        shutdown();
+    }
+}
+
+uint32_t RedPeer::recive(uint8_t *buf, uint32_t size)
+{
+    uint8_t *pos = buf;
+    while (size) {
+        int now;
+        if (_ctx == NULL) {
+            if ((now = recv(_peer, (char *)pos, size, 0)) <= 0) {
+                int err = sock_error();
+                if (now == SOCKET_ERROR && err == WOULDBLOCK_ERR) {
+                    break;
+                }
+
+                if (now == 0 || err == SHUTDOWN_ERR) {
+                    throw RedPeer::DisconnectedException();
+                }
+
+                if (err == INTERRUPTED_ERR) {
+                    continue;
+                }
+                THROW_ERR(SPICEC_ERROR_CODE_RECV_FAILED, "%s (%d)", sock_err_message(err), err);
+            }
+            size -= now;
+            pos += now;
+        } else {
+            if ((now = SSL_read(_ssl, pos, size)) <= 0) {
+                int ssl_error = SSL_get_error(_ssl, now);
+
+                if (ssl_error == SSL_ERROR_WANT_READ) {
+                    break;
+                }
+
+                if (ssl_error == SSL_ERROR_SYSCALL) {
+                    int err = sock_error();
+                    if (now == -1) {
+                        if (err == WOULDBLOCK_ERR) {
+                            break;
+                        }
+                        if (err == INTERRUPTED_ERR) {
+                            continue;
+                        }
+                    }
+                    if (now == 0 || (now == -1 && err == SHUTDOWN_ERR)) {
+                        throw RedPeer::DisconnectedException();
+                    }
+                    THROW_ERR(SPICEC_ERROR_CODE_SEND_FAILED, "%s (%d)", sock_err_message(err), err);
+                } else if (ssl_error == SSL_ERROR_ZERO_RETURN) {
+                    throw RedPeer::DisconnectedException();
+                }
+                THROW_ERR(SPICEC_ERROR_CODE_RECV_FAILED, "ssl error %d", ssl_error);
+            }
+            size -= now;
+            pos += now;
+        }
+    }
+    return pos - buf;
+}
+
+RedPeer::CompundInMessage* RedPeer::recive()
+{
+    RedDataHeader header;
+    std::auto_ptr<CompundInMessage> message;
+
+    recive((uint8_t*)&header, sizeof(RedDataHeader));
+    message.reset(new CompundInMessage(header.serial, header.type, header.size, header.sub_list));
+    recive(message->data(), message->compund_size());
+    return message.release();
+}
+
+uint32_t RedPeer::send(uint8_t *buf, uint32_t size)
+{
+    uint8_t *pos = buf;
+    while (size) {
+        int now;
+
+        if (_ctx == NULL) {
+            if ((now = ::send(_peer, (char *)pos, size, 0)) == SOCKET_ERROR) {
+                int err = sock_error();
+                if (err == WOULDBLOCK_ERR) {
+                    break;
+                }
+                if (err == SHUTDOWN_ERR) {
+                    throw RedPeer::DisconnectedException();
+                }
+                if (err == INTERRUPTED_ERR) {
+                    continue;
+                }
+                THROW_ERR(SPICEC_ERROR_CODE_SEND_FAILED, "%s (%d)", sock_err_message(err), err);
+            }
+            size -= now;
+            pos += now;
+        } else {
+            if ((now = SSL_write(_ssl, pos, size)) <= 0) {
+                int ssl_error = SSL_get_error(_ssl, now);
+
+                if (ssl_error == SSL_ERROR_WANT_WRITE) {
+                    break;
+                }
+                if (ssl_error == SSL_ERROR_SYSCALL) {
+                    int err = sock_error();
+                    if (now == -1) {
+                        if (err == WOULDBLOCK_ERR) {
+                            break;
+                        }
+                        if (err == INTERRUPTED_ERR) {
+                            continue;
+                        }
+                    }
+                    if (now == 0 || (now == -1 && err == SHUTDOWN_ERR)) {
+                        throw RedPeer::DisconnectedException();
+                    }
+                    THROW_ERR(SPICEC_ERROR_CODE_SEND_FAILED, "%s (%d)", sock_err_message(err), err);
+                } else if (ssl_error == SSL_ERROR_ZERO_RETURN) {
+                    throw RedPeer::DisconnectedException();
+                }
+                THROW_ERR(SPICEC_ERROR_CODE_SEND_FAILED, "ssl error %d", ssl_error);
+            }
+            size -= now;
+            pos += now;
+        }
+    }
+    return pos - buf;
+}
+
+uint32_t RedPeer::send(RedPeer::OutMessage& message)
+{
+    message.header().serial = ++_serial;
+    return send(message.base(), message.message_size());
+}
+
+RedPeer::OutMessage::OutMessage(uint32_t type, uint32_t size)
+    : _data (new uint8_t[size + sizeof(RedDataHeader)])
+    , _size (size)
+{
+    header().type = type;
+    header().size = size;
+}
+
+RedPeer::OutMessage::~OutMessage()
+{
+    delete[] _data;
+}
+
+void RedPeer::OutMessage::resize(uint32_t size)
+{
+    if (size <= _size) {
+        header().size = size;
+        return;
+    }
+    uint32_t type = header().type;
+    delete[] _data;
+    _data = NULL;
+    _size = 0;
+    _data = new uint8_t[size + sizeof(RedDataHeader)];
+    _size = size;
+    header().type = type;
+    header().size = size;
+}
+
diff --git a/client/red_peer.h b/client/red_peer.h
new file mode 100644
index 00000000..f1db1814
--- /dev/null
+++ b/client/red_peer.h
@@ -0,0 +1,182 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REDPEER
+#define _H_REDPEER
+
+#ifdef _WIN32
+#include <winsock.h>
+#else
+typedef int SOCKET;
+#endif
+
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include "common.h"
+#include "red.h"
+#include "events_loop.h"
+#include "threads.h"
+
+class RedPeer: protected EventsLoop::Socket {
+public:
+    RedPeer();
+    virtual ~RedPeer();
+
+    class InMessage;
+    class CompundInMessage;
+    class OutMessage;
+    class DisconnectedException {};
+
+    class ConnectionOptions {
+    public:
+
+        enum Type {
+            CON_OP_INVALID,
+            CON_OP_SECURE,
+            CON_OP_UNSECURE,
+            CON_OP_BOTH,
+        };
+
+        ConnectionOptions(Type in_type, int in_port, int in_sport)
+            : type (in_type)
+            , unsecure_port (in_port)
+            , secure_port (in_sport)
+        {
+        }
+
+        virtual ~ConnectionOptions() {}
+
+        bool allow_secure() const
+        {
+            return (type == CON_OP_BOTH || type == CON_OP_SECURE) && secure_port != -1;
+        }
+
+        bool allow_unsecure() const
+        {
+            return (type == CON_OP_BOTH || type == CON_OP_UNSECURE) && unsecure_port != -1;
+        }
+
+    public:
+        Type type;
+        int unsecure_port;
+        int secure_port;
+    };
+
+    void connect_unsecure(uint32_t ip, int port);
+    void connect_unsecure(const char* host, int port);
+
+    void connect_secure(const ConnectionOptions& options, uint32_t ip);
+    void connect_secure(const ConnectionOptions& options, const char* host);
+
+    void disconnect();
+    void swap(RedPeer* other);
+    void close();
+    void enable() { _shut = false;}
+
+    virtual CompundInMessage* recive();
+    uint32_t send(OutMessage& message);
+
+    uint32_t recive(uint8_t* buf, uint32_t size);
+    uint32_t send(uint8_t* buf, uint32_t size);
+
+    static uint32_t host_by_name(const char *host);
+
+protected:
+    virtual void on_event() {}
+    virtual int get_socket() { return _peer;}
+
+private:
+    void shutdown();
+    void cleanup();
+
+private:
+    SOCKET _peer;
+    Mutex _lock;
+    bool _shut;
+    uint64_t _serial;
+
+    SSL_CTX *_ctx;
+    SSL *_ssl;
+};
+
+class RedPeer::InMessage {
+public:
+    InMessage(uint16_t type, uint32_t size, uint8_t* data)
+        : _type (type)
+        , _size (size)
+        , _data (data)
+    {
+    }
+
+    virtual ~InMessage() {}
+
+    uint16_t type() { return _type;}
+    uint8_t* data() { return _data;}
+    virtual uint32_t size() { return _size;}
+
+protected:
+    uint16_t _type;
+    uint32_t _size;
+    uint8_t* _data;
+};
+
+class RedPeer::CompundInMessage: public RedPeer::InMessage {
+public:
+    CompundInMessage(uint64_t _serial, uint16_t type, uint32_t size, uint32_t sub_list)
+        : InMessage(type, size, new uint8_t[size])
+        , _serial (_serial)
+        , _sub_list (sub_list)
+    {
+    }
+
+    virtual ~CompundInMessage() { delete[] _data;}
+
+    uint64_t serial() { return _serial;}
+    uint32_t sub_list() { return _sub_list;}
+
+    virtual uint32_t size() { return _sub_list ? _sub_list : _size;}
+    uint32_t compund_size() {return _size;}
+
+private:
+    uint64_t _serial;
+    uint32_t _sub_list;
+};
+
+class RedPeer::OutMessage {
+public:
+    OutMessage(uint32_t type, uint32_t size);
+    virtual ~OutMessage();
+
+    RedDataHeader& header() { return *(RedDataHeader *)_data;}
+    uint8_t* data() { return _data + sizeof(RedDataHeader);}
+    void resize(uint32_t size);
+
+private:
+    uint32_t message_size() { return header().size + sizeof(RedDataHeader);}
+    uint8_t* base() { return _data;}
+
+private:
+    uint8_t* _data;
+    uint32_t _size;
+
+    friend class RedPeer;
+    friend class RedChannel;
+};
+
+#endif
+
diff --git a/client/red_pixmap.h b/client/red_pixmap.h
new file mode 100644
index 00000000..5b9ac09a
--- /dev/null
+++ b/client/red_pixmap.h
@@ -0,0 +1,53 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_PIXMAP
+#define _H_RED_PIXMAP
+
+#include "red_drawable.h"
+
+class RedPixmap: public RedDrawable {
+public:
+    enum Format {
+        ARGB32,
+        RGB32,
+        A1,
+    };
+
+    RedPixmap(int width, int height, Format format, bool top_bottom,
+              rgb32_t* pallete);
+    virtual ~RedPixmap();
+
+    virtual Point get_size() { Point pt = {_width, _height}; return pt;}
+
+    int get_width() { return _width;}
+    int get_height() { return _height;}
+    int get_stride() { return _stride;}
+    uint8_t* get_data() { return _data;}
+    bool is_big_endian_bits();
+
+protected:
+    Format _format;
+    int _width;
+    int _height;
+    int _stride;
+    bool _top_bottom;
+    uint8_t* _data;
+};
+
+#endif
+
diff --git a/client/red_pixmap_cairo.h b/client/red_pixmap_cairo.h
new file mode 100644
index 00000000..aec9c35f
--- /dev/null
+++ b/client/red_pixmap_cairo.h
@@ -0,0 +1,32 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_PIXMAP_CAIRO
+#define _H_RED_PIXMAP_CAIRO
+
+#include "red_pixmap.h"
+#include "red_window.h"
+
+class RedPixmapCairo: public RedPixmap {
+public:
+    RedPixmapCairo(int width, int height, Format format, bool top_bottom,
+                   rgb32_t *pallete, RedWindow *win);
+    ~RedPixmapCairo();
+};
+
+#endif
+
diff --git a/client/red_pixmap_gdi.h b/client/red_pixmap_gdi.h
new file mode 100644
index 00000000..d5a028a8
--- /dev/null
+++ b/client/red_pixmap_gdi.h
@@ -0,0 +1,36 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_PIXMAP_CAIRO
+#define _H_RED_PIXMAP_CAIRO
+
+#include "red_pixmap.h"
+
+class Mutex;
+
+class RedPixmapGdi: public RedPixmap {
+public:
+    RedPixmapGdi(int width, int height, Format format, bool top_bottom,
+                 rgb32_t *pallete);
+    HDC get_dc();
+    void *get_memptr();
+    ~RedPixmapGdi();
+    Mutex& get_mutex();
+};
+
+#endif
+
diff --git a/client/red_pixmap_gl.h b/client/red_pixmap_gl.h
new file mode 100644
index 00000000..d86ddb47
--- /dev/null
+++ b/client/red_pixmap_gl.h
@@ -0,0 +1,50 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_PIXMAP_GL
+#define _H_RED_PIXMAP_GL
+
+#include "red_pixmap.h"
+#include "red_window.h"
+
+enum RenderType {
+    RENDER_TYPE_PBUFF,
+    RENDER_TYPE_FBO,
+};
+
+class RedPixmapGL: public RedPixmap {
+public:
+    RedPixmapGL(int width, int height, Format format, bool top_bottom,
+                rgb32_t *pallete, RedWindow *win, RenderType rendertype);
+
+    void textures_lost();
+    void touch_context();
+    void update_texture(const Rect *bbox);
+    void pre_copy();
+    void past_copy();
+    ~RedPixmapGL();
+
+private:
+    RedGlContext _glcont;
+    GLint _prev_tex;
+    GLint _prev_matrix_mode;
+    bool _tex_enabled;
+    bool _textures_lost;
+};
+
+#endif
+
diff --git a/client/red_types.h b/client/red_types.h
new file mode 100644
index 00000000..a0fea72f
--- /dev/null
+++ b/client/red_types.h
@@ -0,0 +1,38 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_TYPES
+#define _H_RED_TYPES
+
+struct PixmapHeader {
+    uint8_t* data;
+    int width;
+    int height;
+    int stride;
+};
+
+struct IconHeader {
+    int width;
+    int height;
+    uint8_t* pixmap;
+    uint8_t* mask;
+};
+
+class RedDrawable;
+
+#endif
+
diff --git a/client/red_window.h b/client/red_window.h
new file mode 100644
index 00000000..e3565765
--- /dev/null
+++ b/client/red_window.h
@@ -0,0 +1,193 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_WINDOW
+#define _H_RED_WINDOW
+
+#include "red_drawable.h"
+#include "red.h"
+#include "red_key.h"
+#include "red_window_p.h"
+#include "cursor.h"
+
+class Menu;
+class Icon;
+
+class RedWindow: public RedDrawable, private RedWindow_p {
+public:
+    class Listener;
+
+    enum {
+        DEFAULT_SCREEN = -1,
+    };
+
+    RedWindow(RedWindow::Listener& listener, int screen_id = DEFAULT_SCREEN);
+    virtual ~RedWindow();
+
+    void move_and_resize(int x, int y, int width, int height);
+    void resize(int width, int height);
+    void move(int x, int y);
+    void position_after(RedWindow *after);
+    void raise();
+    void show(int screen_id);
+    void external_show();
+    void hide();
+    void minimize();
+    void activate();
+    void set_title(std::wstring& title);
+    void set_icon(Icon *icon);
+
+    enum Type {
+        TYPE_INVALID,
+        TYPE_NORMAL,
+        TYPE_FULLSCREEN,
+    };
+    void set_type(Type type) { _type = type;}
+    Point get_position();
+    virtual Point get_size();
+    bool get_mouse_anchor_point(Point& pt);
+
+    void set_mouse_position(int x, int y);
+    void set_cursor(LocalCursor* local_cursor);
+    void hide_cursor();
+    void show_cursor();
+    void cupture_mouse();
+    void release_mouse();
+    void start_key_interception();
+    void stop_key_interception();
+    void set_menu(Menu* menu);
+
+#ifdef USE_OGL
+    void untouch_context();
+    RedGlContext create_context_gl();
+    RedPbuffer create_pbuff(int width, int height);
+    void set_render_pbuff(RedPbuffer pbuff);
+    void set_render_fbo(GLuint fbo);
+    void set_gl_context(RedGlContext context);
+#endif
+
+    int get_screen_num();
+
+    void set_type_gl();
+    void unset_type_gl();
+
+    static void init();
+
+    Listener& get_listener() { return _listener;}
+
+private:
+    void on_focus_in();
+    void on_focus_out();
+    void on_pointer_enter();
+    void on_pointer_leave();
+
+    void do_start_key_interception();
+    void do_stop_key_interception();
+
+private:
+    Listener& _listener;
+    Point _window_size;
+    Type _type;
+    LocalCursor* _local_cursor;
+    bool _cursor_visible;
+    bool _focused;
+    bool _pointer_in_window;
+    bool _key_interception;
+    Menu* _menu;
+
+    friend class RedWindow_p;
+};
+
+class RedWindow::Listener {
+public:
+    virtual ~Listener() {}
+    virtual void on_exposed_rect(const Rect& area) = 0;
+    virtual void on_mouse_motion(int x, int y, unsigned int buttons_state) = 0;
+    virtual void on_key_press(RedKey key) = 0;
+    virtual void on_key_release(RedKey key) = 0;
+    virtual void on_button_press(RedButton button, unsigned int buttons_state) = 0;
+    virtual void on_button_release(RedButton button, unsigned int buttons_state) = 0;
+    virtual void on_deactivate() = 0;
+    virtual void on_activate() = 0;
+    virtual void on_pointer_enter() = 0;
+    virtual void on_pointer_leave() = 0;
+    virtual void on_start_key_interception() = 0;
+    virtual void on_stop_key_interception() = 0;
+    virtual void enter_modal_loop() = 0;
+    virtual void exit_modal_loop() = 0;
+
+    virtual void pre_migrate() { }
+    virtual void post_migrate() { }
+};
+
+/*class REGION {
+    void get_bbox(Rect& bbox) const;
+    bool contains_point(int x, int y) const;
+
+};*/
+
+template <class REGION>
+static bool find_anchor_point(const REGION& region, Point& pt)
+{
+    static const unsigned int lookup_size = 20;
+    unsigned int width;
+    unsigned int height;
+    Rect bbox;
+
+    region.get_bbox(bbox);
+    width = bbox.right - bbox.left;
+    height = bbox.bottom - bbox.top;
+
+    int div = 2;
+
+    for (;;) {
+        unsigned int h_unit;
+        unsigned int v_unit;
+
+        if ((v_unit = height / div) * 2 < lookup_size || (h_unit = width / div) * 2 < lookup_size) {
+            return false;
+        }
+
+        for (unsigned int y = v_unit; y < v_unit * div; y += v_unit * 2) {
+            for (unsigned int x = h_unit; x < h_unit * div; x += h_unit * 2) {
+                if (!region.contains_point(bbox.left + x, bbox.top + y)) {
+                    continue;
+                }
+
+                Rect r;
+                r.left = bbox.left + x - lookup_size / 2;
+                r.right = r.left + lookup_size;
+                r.top = bbox.top + y - lookup_size / 2;
+                r.bottom = r.top + lookup_size;
+
+                if (!region.contains_point(r.left, r.top) ||
+                    !region.contains_point(r.right, r.top) ||
+                    !region.contains_point(r.left, r.bottom) ||
+                    !region.contains_point(r.right, r.bottom)) {
+                    continue;
+                }
+                pt.x = bbox.left + x;
+                pt.y = bbox.top + y;
+                return true;
+            }
+        }
+        div *= 2;
+    }
+}
+
+#endif
+
diff --git a/client/region.cpp b/client/region.cpp
new file mode 100644
index 00000000..dc0373c4
--- /dev/null
+++ b/client/region.cpp
@@ -0,0 +1,20 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "../common/region.c"
+
diff --git a/client/rop3.cpp b/client/rop3.cpp
new file mode 100644
index 00000000..5e5b4814
--- /dev/null
+++ b/client/rop3.cpp
@@ -0,0 +1,20 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "../common/rop3.c"
+
diff --git a/client/screen.cpp b/client/screen.cpp
new file mode 100644
index 00000000..b33560ee
--- /dev/null
+++ b/client/screen.cpp
@@ -0,0 +1,777 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "screen.h"
+#include "application.h"
+#include "screen_layer.h"
+#include "utils.h"
+#include "debug.h"
+#include "monitor.h"
+#include "red_pixmap_cairo.h"
+#include "resource.h"
+#include "icon.h"
+
+class UpdateEvent: public Event {
+public:
+    UpdateEvent(int screen) : _screen (screen) {}
+
+    virtual void responce(Application& application)
+    {
+        RedScreen* screen = application.find_screen(_screen);
+        if (screen) {
+            screen->update();
+        }
+    }
+
+private:
+    int _screen;
+};
+
+void periodic_update_proc(void *opaque, TimerID timer)
+{
+    RedScreen* screen = (RedScreen*)opaque;
+
+    screen->periodic_update();
+}
+
+RedScreen::RedScreen(Application& owner, int id, const std::wstring& name, int width, int height)
+    : _owner (owner)
+    , _id (id)
+    , _refs (1)
+    , _window (*this)
+    , _active (false)
+    , _captured (false)
+    , _full_screen (false)
+    , _out_of_sync (false)
+    , _frame_area (false)
+    , _cursor_visible (true)
+    , _periodic_update (false)
+    , _key_interception (false)
+    , _update_by_timer (true)
+    , _forec_update_timer (0)
+    , _update_timer (INVALID_TIMER)
+    , _composit_area (NULL)
+    , _update_mark (1)
+    , _monitor (NULL)
+    , _default_cursor (NULL)
+    , _active_cursor (NULL)
+    , _inactive_cursor (NULL)
+    , _pointer_location (POINTER_OUTSIDE_WINDOW)
+    , _pixel_format_index (0)
+    , _update_interrupt_trigger (NULL)
+{
+    region_init(&_dirty_region);
+    set_name(name);
+    _size.x = width;
+    _size.y = height;
+    _origin.x = _origin.y = 0;
+    create_composit_area();
+    _window.resize(_size.x, _size.y);
+    save_position();
+    _update_timer = Platform::create_interval_timer(periodic_update_proc, this);
+    if (_update_timer == INVALID_TIMER) {
+        THROW("create timer failed");
+    }
+    if ((_default_cursor = Platform::create_default_cursor()) == NULL) {
+        THROW("create default cursor failed");
+    }
+    if ((_inactive_cursor = Platform::create_inactive_cursor()) == NULL) {
+        THROW("create inactive cursor failed");
+    }
+    _window.set_cursor(_default_cursor);
+    AutoRef<Menu> menu(_owner.get_app_menu());
+    _window.set_menu(*menu);
+    AutoRef<Icon> icon(Platform::load_icon(RED_ICON_RES_ID));
+    _window.set_icon(*icon);
+}
+
+RedScreen::~RedScreen()
+{
+    bool captured = is_captured();
+    relase_inputs();
+    destroy_composit_area();
+    Platform::destroy_interval_timer(_update_timer);
+    _owner.on_screen_destroyed(_id, captured);
+    region_destroy(&_dirty_region);
+    if (_default_cursor) {
+        _default_cursor->unref();
+    }
+    if (_active_cursor) {
+        _active_cursor->unref();
+    }
+    if (_inactive_cursor) {
+        _inactive_cursor->unref();
+    }
+}
+
+void RedScreen::show(bool activate, RedScreen* pos)
+{
+    _window.position_after((pos) ? &pos->_window : NULL);
+    show();
+    if (activate) {
+        _window.activate();
+    }
+}
+
+RedScreen* RedScreen::ref()
+{
+    _refs++;
+    return this;
+}
+
+void RedScreen::unref()
+{
+    if (!--_refs) {
+        delete this;
+    }
+}
+
+void RedScreen::destroy_composit_area()
+{
+    if (_composit_area) {
+        delete _composit_area;
+        _composit_area = NULL;
+    }
+}
+
+void RedScreen::create_composit_area()
+{
+    destroy_composit_area();
+    _composit_area = new RedPixmapCairo(_size.x, _size.y, RedPixmap::RGB32,
+                                        false, NULL, NULL);
+}
+
+void RedScreen::adjust_window_rect(int x, int y)
+{
+    _window.move_and_resize(x, y, _size.x, _size.y);
+}
+
+void RedScreen::set_mode(int width, int height, int depth)
+{
+    RecurciveLock lock(_update_lock);
+    _size.x = width;
+    _size.y = height;
+    create_composit_area();
+    if (_full_screen) {
+        bool cuptur = _owner.rearrange_monitors(*this);
+        __show_full_screen();
+        if (cuptur) {
+            capture_inputs();
+        }
+    } else {
+        _window.resize(_size.x, _size.y);
+    }
+    notify_new_size();
+}
+
+void RedScreen::set_name(const std::wstring& name)
+{
+    if (!name.empty()) {
+        wstring_printf(_name, name.c_str(), _id);
+    }
+    _window.set_title(_name);
+}
+
+void RedScreen::attach_layer(ScreenLayer& layer)
+{
+    RecurciveLock lock(_update_lock);
+    int order = layer.z_order();
+
+    if ((int)_layes.size() < order + 1) {
+        _layes.resize(order + 1);
+    }
+    if (_layes[order]) {
+        THROW("layer in use");
+    }
+    layer.set_screen(this);
+    _layes[order] = &layer;
+    ref();
+    lock.unlock();
+    layer.invalidate();
+}
+
+void RedScreen::detach_layer(ScreenLayer& layer)
+{
+    RecurciveLock lock(_update_lock);
+    int order = layer.z_order();
+
+    if ((int)_layes.size() < order + 1 || _layes[order] != &layer) {
+        THROW("not found");
+    }
+    QRegion layer_area;
+    region_clone(&layer_area, &layer.area());
+    _layes[order]->set_screen(NULL);
+    _layes[order] = NULL;
+    lock.unlock();
+    invalidate(layer_area);
+    region_destroy(&layer_area);
+    unref();
+}
+
+void RedScreen::composit_to_screen(RedDrawable& win_dc, const QRegion& region)
+{
+    for (int i = 0; i < (int)region.num_rects; i++) {
+        Rect* r = &region.rects[i];
+        win_dc.copy_pixels(*_composit_area, r->left, r->top, *r);
+    }
+}
+
+void RedScreen::notify_new_size()
+{
+    for (int i = 0; i < (int)_layes.size(); i++) {
+        if (!_layes[i]) {
+            continue;
+        }
+        _layes[i]->on_size_changed();
+    }
+}
+
+inline void RedScreen::begin_update(QRegion& direct_rgn, QRegion& composit_rgn,
+                                    QRegion& frame_rgn)
+{
+    region_init(&composit_rgn);
+    RecurciveLock lock(_update_lock);
+    region_clone(&direct_rgn, &_dirty_region);
+    region_clear(&_dirty_region);
+    _update_mark++;
+    lock.unlock();
+
+    QRegion rect_rgn;
+    Rect r;
+    r.top = r.left = 0;
+    r.right = _size.x;
+    r.bottom = _size.y;
+    region_init(&rect_rgn);
+    region_add(&rect_rgn, &r);
+
+    if (_frame_area) {
+        region_clone(&frame_rgn, &direct_rgn);
+        region_exclude(&frame_rgn, &rect_rgn);
+    }
+    region_and(&direct_rgn, &rect_rgn);
+    region_destroy(&rect_rgn);
+
+    for (int i = _layes.size() - 1; i >= 0; i--) {
+        ScreenLayer* layer;
+
+        if (!(layer = _layes[i])) {
+            continue;
+        }
+        layer->begin_update(direct_rgn, composit_rgn);
+    }
+}
+
+inline void RedScreen::update_done()
+{
+    for (unsigned int i = 0; i < _layes.size(); i++) {
+        ScreenLayer* layer;
+
+        if (!(layer = _layes[i])) {
+            continue;
+        }
+        layer->on_update_completion(_update_mark - 1);
+    }
+}
+
+inline void RedScreen::update_composit(QRegion& composit_rgn)
+{
+    erase_background(*_composit_area, composit_rgn);
+    for (int i = 0; i < (int)_layes.size(); i++) {
+        ScreenLayer* layer;
+
+        if (!(layer = _layes[i])) {
+            continue;
+        }
+        QRegion& dest_region = layer->composit_area();
+        region_or(&composit_rgn, &dest_region);
+        layer->copy_pixels(dest_region, *_composit_area);
+    }
+}
+
+inline void RedScreen::draw_direct(RedDrawable& win_dc, QRegion& direct_rgn, QRegion& composit_rgn,
+                                   QRegion& frame_rgn)
+{
+    erase_background(win_dc, direct_rgn);
+
+    if (_frame_area) {
+        erase_background(win_dc, frame_rgn);
+        region_destroy(&frame_rgn);
+    }
+
+    for (int i = 0; i < (int)_layes.size(); i++) {
+        ScreenLayer* layer;
+
+        if (!(layer = _layes[i])) {
+            continue;
+        }
+        QRegion& dest_region = layer->direct_area();
+        layer->copy_pixels(dest_region, win_dc);
+    }
+}
+
+void RedScreen::periodic_update()
+{
+    bool need_update;
+    RecurciveLock lock(_update_lock);
+    if (is_dirty()) {
+        need_update = true;
+    } else {
+        if (!_forec_update_timer) {
+            Platform::deactivate_interval_timer(_update_timer);
+            _periodic_update = false;
+        }
+        need_update = false;
+    }
+    lock.unlock();
+
+    if (need_update) {
+        if (update_by_interrupt()) {
+            interrupt_update();
+        } else {
+            update();
+        }
+    }
+}
+
+void RedScreen::activate_timer()
+{
+    RecurciveLock lock(_update_lock);
+    if (_periodic_update) {
+        return;
+    }
+    _periodic_update = true;
+    lock.unlock();
+    if (!Platform::activate_interval_timer(_update_timer, 1000 / 30)) {
+        LOG_WARN("failed");
+    }
+}
+
+void RedScreen::update()
+{
+    if (is_out_of_sync()) {
+        return;
+    }
+
+    QRegion direct_rgn;
+    QRegion composit_rgn;
+    QRegion frame_rgn;
+
+    begin_update(direct_rgn, composit_rgn, frame_rgn);
+    update_composit(composit_rgn);
+    draw_direct(_window, direct_rgn, composit_rgn, frame_rgn);
+    composit_to_screen(_window, composit_rgn);
+    update_done();
+    region_destroy(&direct_rgn);
+    region_destroy(&composit_rgn);
+
+    if (_update_by_timer) {
+        activate_timer();
+    }
+}
+
+bool RedScreen::_invalidate(const Rect& rect, bool urgent, uint64_t& update_mark)
+{
+    RecurciveLock lock(_update_lock);
+    bool update_triger = !is_dirty() && (urgent || !_periodic_update);
+    region_add(&_dirty_region, &rect);
+    update_mark = _update_mark;
+    return update_triger;
+}
+
+uint64_t RedScreen::invalidate(const Rect& rect, bool urgent)
+{
+    uint64_t update_mark;
+    if (_invalidate(rect, urgent, update_mark)) {
+        if (!urgent && _update_by_timer) {
+            activate_timer();
+        } else {
+            if (update_by_interrupt()) {
+                interrupt_update();
+            } else {
+                AutoRef<UpdateEvent> update_event(new UpdateEvent(_id));
+                _owner.push_event(*update_event);
+            }
+        }
+    }
+    return update_mark;
+}
+
+void RedScreen::invalidate(const QRegion &region)
+{
+    Rect *r = region.rects;
+    Rect *end = r + region.num_rects;
+    while (r != end) {
+        invalidate(*r++, false);
+    }
+}
+
+inline void RedScreen::erase_background(RedDrawable& dc, const QRegion& composit_rgn)
+{
+    for (int i = 0; i < (int)composit_rgn.num_rects; i++) {
+        dc.fill_rect(composit_rgn.rects[i], 0);
+    }
+}
+
+void RedScreen::reset_mouse_pos()
+{
+    _window.set_mouse_position(_mouse_anchor_point.x, _mouse_anchor_point.y);
+}
+
+void RedScreen::capture_inputs()
+{
+    if (_captured || !_window.get_mouse_anchor_point(_mouse_anchor_point)) {
+        return;
+    }
+    if (_owner.get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+        _window.hide_cursor();
+        reset_mouse_pos();
+        _window.cupture_mouse();
+    }
+#ifndef NO_KEY_GRAB
+    _window.start_key_interception();
+#endif
+    _captured = true;
+}
+
+void RedScreen::relase_inputs()
+{
+    if (!_captured) {
+        return;
+    }
+#ifndef NO_KEY_GRAB
+    _window.stop_key_interception();
+#endif
+    _captured = false;
+    _window.release_mouse();
+    if (_owner.get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+        _window.set_cursor(_default_cursor);
+    }
+}
+
+void RedScreen::set_cursor(CursorData* cursor)
+{
+    if (cursor) {
+        if (_active_cursor) {
+            _active_cursor->unref();
+        }
+        if (!cursor->get_local()) {
+            AutoRef<LocalCursor> cur(Platform::create_local_cursor(cursor));
+            if (*cur == NULL) {
+                THROW("create local cursor failed");
+            }
+            cursor->set_local(*cur);
+            _active_cursor = (*cur)->ref();
+        } else {
+            _active_cursor = (cursor->get_local())->ref();
+        }
+    }
+    _cursor_visible = !!cursor;
+    update_active_cursor();
+}
+
+void RedScreen::update_active_cursor()
+{
+    if (_owner.get_mouse_mode() == RED_MOUSE_MODE_CLIENT &&
+                                                      _pointer_location == POINTER_IN_ACTIVE_AREA) {
+        if (_cursor_visible && _active_cursor) {
+            _window.set_cursor(_active_cursor);
+        } else {
+            _window.hide_cursor();
+        }
+    }
+}
+
+void RedScreen::on_mouse_motion(int x, int y, unsigned int buttons_state)
+{
+    switch (_owner.get_mouse_mode()) {
+    case RED_MOUSE_MODE_CLIENT:
+        if (!_frame_area) {
+            _owner.on_mouse_position(x, y, buttons_state, _id);
+        } else if (x >= 0 && x < _size.x && y >= 0 && y < _size.y) {
+            _owner.on_mouse_position(x, y, buttons_state, _id);
+            if (_pointer_location != POINTER_IN_ACTIVE_AREA) {
+                _pointer_location = POINTER_IN_ACTIVE_AREA;
+                update_active_cursor();
+            }
+        } else if (_pointer_location != POINTER_IN_FRAME_AREA) {
+            _pointer_location = POINTER_IN_FRAME_AREA;
+            _window.set_cursor(_inactive_cursor);
+        }
+        break;
+    case RED_MOUSE_MODE_SERVER:
+        if (_captured && (x != _mouse_anchor_point.x || y != _mouse_anchor_point.y)) {
+            _owner.on_mouse_motion(x - _mouse_anchor_point.x,
+                                   y - _mouse_anchor_point.y,
+                                   buttons_state);
+            reset_mouse_pos();
+        }
+        break;
+    default:
+        THROW("invalid mouse mode");
+    }
+}
+
+void RedScreen::on_button_press(RedButton button, unsigned int buttons_state)
+{
+    if (_owner.get_mouse_mode() == RED_MOUSE_MODE_CLIENT &&
+                                                      _pointer_location != POINTER_IN_ACTIVE_AREA) {
+        return;
+    }
+    if (!mouse_is_captured()) {
+        if (_owner.get_mouse_mode() == RED_MOUSE_MODE_SERVER && button != REDC_MOUSE_LBUTTON) {
+            return;
+        }
+        capture_inputs();
+        if (_owner.get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+            return;
+        }
+    }
+    _owner.on_mouse_down(button, buttons_state);
+}
+
+void RedScreen::on_button_release(RedButton button, unsigned int buttons_state)
+{
+    if (!mouse_is_captured()) {
+        if (_owner.get_mouse_mode() == RED_MOUSE_MODE_SERVER) {
+            return;
+        }
+        capture_inputs();
+    }
+    _owner.on_mouse_up(button, buttons_state);
+}
+
+void RedScreen::on_key_press(RedKey key)
+{
+    _owner.on_key_down(key);
+}
+
+void RedScreen::on_key_release(RedKey key)
+{
+    _owner.on_key_up(key);
+}
+
+void RedScreen::on_deactivate()
+{
+    relase_inputs();
+    _active = false;
+    _owner.on_deactivate_screen(this);
+}
+
+void RedScreen::on_activate()
+{
+    _active = true;
+    _owner.on_activate_screen(this);
+}
+
+void RedScreen::on_pointer_enter()
+{
+    if (!_frame_area) {
+        _pointer_location = POINTER_IN_ACTIVE_AREA;
+        update_active_cursor();
+    }
+}
+
+void RedScreen::on_pointer_leave()
+{
+    _pointer_location = POINTER_OUTSIDE_WINDOW;
+}
+
+void RedScreen::enter_modal_loop()
+{
+    _forec_update_timer++;
+    activate_timer();
+}
+
+void RedScreen::exit_modal_loop()
+{
+    ASSERT(_forec_update_timer > 0)
+    _forec_update_timer--;
+}
+
+void RedScreen::pre_migrate()
+{
+    for (int i = 0; i < (int)_layes.size(); i++) {
+        if (!_layes[i]) {
+            continue;
+        }
+        _layes[i]->pre_migrate();
+    }
+}
+
+void RedScreen::post_migrate()
+{
+    for (int i = 0; i < (int)_layes.size(); i++) {
+        if (!_layes[i]) {
+            continue;
+        }
+        _layes[i]->post_migrate();
+    }
+}
+
+void RedScreen::exit_full_screen()
+{
+    if (!_full_screen) {
+        return;
+    }
+    RecurciveLock lock(_update_lock);
+    _window.hide();
+    region_clear(&_dirty_region);
+    _window.set_type(RedWindow::TYPE_NORMAL);
+    adjust_window_rect(_save_pos.x, _save_pos.y);
+    _origin.x = _origin.y = 0;
+    _window.set_origin(0, 0);
+    show();
+    _full_screen = false;
+    _out_of_sync = false;
+    _frame_area = false;
+}
+
+void RedScreen::save_position()
+{
+    _save_pos = _window.get_position();
+}
+
+void RedScreen::__show_full_screen()
+{
+    if (!_monitor) {
+        hide();
+        return;
+    }
+    Point position = _monitor->get_position();
+    Point monitor_size = _monitor->get_size();
+    _frame_area = false;
+    region_clear(&_dirty_region);
+    _window.set_type(RedWindow::TYPE_FULLSCREEN);
+    _window.move_and_resize(position.x, position.y, monitor_size.x, monitor_size.y);
+
+    if (!(_out_of_sync = _monitor->is_out_of_sync())) {
+        ASSERT(monitor_size.x >= _size.x);
+        ASSERT(monitor_size.y >= _size.y);
+        _origin.x = (monitor_size.x - _size.x) / 2;
+        _origin.y = (monitor_size.y - _size.y) / 2;
+        _frame_area = monitor_size.x != _size.x || monitor_size.y != _size.y;
+    } else {
+        _origin.x = _origin.y = 0;
+    }
+    _window.set_origin(_origin.x, _origin.y);
+    show();
+}
+
+void RedScreen::show_full_screen()
+{
+    if (_full_screen) {
+        return;
+    }
+    RecurciveLock lock(_update_lock);
+    hide();
+    save_position();
+    _full_screen = true;
+    __show_full_screen();
+}
+
+void RedScreen::minimize()
+{
+    _window.minimize();
+}
+
+void RedScreen::position_full_screen(const Point& position)
+{
+    if (!_full_screen) {
+        return;
+    }
+
+    _window.move(position.x, position.y);
+}
+
+void RedScreen::hide()
+{
+    _window.hide();
+}
+
+void RedScreen::show()
+{
+    RecurciveLock lock(_update_lock);
+    _window.show(_monitor ? _monitor->get_screen_id() : 0);
+}
+
+void RedScreen::activate()
+{
+    _window.activate();
+}
+
+void RedScreen::external_show()
+{
+    DBG(0, "Entry");
+    _window.external_show();
+}
+
+void RedScreen::on_exposed_rect(const Rect& area)
+{
+    if (is_out_of_sync()) {
+        _window.fill_rect(area, rgb32_make(0xff, 0xff, 0xff));
+        return;
+    }
+    invalidate(area, false);
+}
+
+int RedScreen::get_screen_id()
+{
+    return _monitor ? _monitor->get_screen_id() : 0;
+}
+
+#ifdef USE_OGL
+void RedScreen::untouch_context()
+{
+    _window.untouch_context();
+}
+
+bool RedScreen::need_recreate_context_gl()
+{
+    if (_full_screen) {
+        return true;
+    }
+    return false;
+}
+
+#endif
+
+void RedScreen::set_update_interrupt_trigger(EventsLoop::Trigger *trigger)
+{
+    _update_interrupt_trigger = trigger;
+}
+
+bool RedScreen::update_by_interrupt()
+{
+    return _update_interrupt_trigger != NULL;
+}
+
+void RedScreen::interrupt_update()
+{
+    _update_interrupt_trigger->trigger();
+}
+
+void RedScreen::set_type_gl()
+{
+    _window.set_type_gl();
+}
+
+void RedScreen::unset_type_gl()
+{
+    _window.unset_type_gl();
+}
+
diff --git a/client/screen.h b/client/screen.h
new file mode 100644
index 00000000..761ae244
--- /dev/null
+++ b/client/screen.h
@@ -0,0 +1,181 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_SCREEN
+#define _H_SCREEN
+
+#include "common.h"
+#include "region.h"
+#include "red_key.h"
+#include "GL/gl.h"
+
+#include "red_window.h"
+#include "platform.h"
+#include "events_loop.h"
+#include "threads.h"
+
+class Application;
+class ScreenLayer;
+class Monitor;
+
+enum {
+    SCREEN_LAYER_DISPLAY,
+    SCREEN_LAYER_CURSOR,
+    SCREEN_LAYER_GUI,
+};
+
+class RedScreen: public RedWindow::Listener {
+public:
+    RedScreen(Application& owner, int id, const std::wstring& name, int width, int height);
+
+    RedScreen* ref();
+    void unref();
+
+    void attach_layer(ScreenLayer& layer);
+    void detach_layer(ScreenLayer& layer);
+    void set_mode(int width, int height, int depth);
+    void set_name(const std::wstring& name);
+    uint64_t invalidate(const Rect& rect, bool urgent);
+    void invalidate(const QRegion &region);
+    void relase_inputs();
+    void capture_inputs();
+    bool is_captured() { return _captured;}
+    bool intercepts_sys_key() { return _key_interception;}
+    Point get_size() { return _size;}
+    bool has_monitor() { return _monitor != 0;}
+    void set_monitor(Monitor *monitor) { _monitor = monitor;}
+    Monitor* get_monitor() { return _monitor;}
+    RedWindow* get_window() { return &_window;}
+    void set_cursor(CursorData* cursor);
+    void exit_full_screen();
+    void minimize();
+    void show(bool activate, RedScreen* pos);
+    void show_full_screen();
+    void position_full_screen(const Point& position);
+    void hide();
+    void show();
+    void activate();
+    void external_show();
+
+    int get_id() { return _id;}
+    int get_screen_id();
+
+#ifdef USE_OGL
+    void untouch_context();
+    bool need_recreate_context_gl();
+#endif
+    void set_update_interrupt_trigger(EventsLoop::Trigger *trigger);
+    bool update_by_interrupt();
+    void interrupt_update();
+    void set_type_gl();
+    void unset_type_gl();
+
+    void update();
+
+private:
+    friend void periodic_update_proc(void *opaque, TimerID timer);
+    friend class UpdateEvent;
+
+    virtual ~RedScreen();
+    void create_composit_area();
+
+    void destroy_composit_area();
+    void erase_background(RedDrawable& dc, const QRegion& region);
+    void notify_new_size();
+    void adjust_window_rect(int x, int y);
+    void save_position();
+    bool is_out_of_sync() { return _out_of_sync;}
+    void __show_full_screen();
+
+    bool _invalidate(const Rect& rect, bool urgent, uint64_t& update_mark);
+    void begin_update(QRegion& direct_rgn, QRegion& composit_rgn, QRegion& frame_rgn);
+    void update_composit(QRegion& composit_rgn);
+    void draw_direct(RedDrawable& win_dc, QRegion& direct_rgn, QRegion& composit_rgn,
+                     QRegion& frame_rgn);
+    void activate_timer();
+    void update_done();
+    void periodic_update();
+    bool is_dirty() {return !region_is_empty(&_dirty_region);}
+    void composit_to_screen(RedDrawable& win_dc, const QRegion& region);
+
+    void reset_mouse_pos();
+    bool mouse_is_captured() { return _captured;}
+    void update_active_cursor();
+
+    virtual void on_exposed_rect(const Rect& area);
+    virtual void on_mouse_motion(int x, int y, unsigned int buttons_state);
+    virtual void on_key_press(RedKey key);
+    virtual void on_key_release(RedKey key);
+    virtual void on_button_press(RedButton button, unsigned int buttons_state);
+    virtual void on_button_release(RedButton button, unsigned int buttons_state);
+    virtual void on_deactivate();
+    virtual void on_activate();
+    virtual void on_pointer_enter();
+    virtual void on_pointer_leave();
+    virtual void on_start_key_interception() { _key_interception = true;}
+    virtual void on_stop_key_interception() { _key_interception = false;}
+    virtual void enter_modal_loop();
+    virtual void exit_modal_loop();
+
+    virtual void pre_migrate();
+    virtual void post_migrate();
+
+private:
+    Application& _owner;
+    int _id;
+    int _refs;
+    std::wstring _name;
+    RedWindow _window;
+    std::vector<ScreenLayer*> _layes;
+    QRegion _dirty_region;
+    RecurciveMutex _update_lock;
+    bool _active;
+    bool _captured;
+    bool _full_screen;
+    bool _out_of_sync;
+    bool _frame_area;
+    bool _cursor_visible;
+    bool _periodic_update;
+    bool _key_interception;
+    bool _update_by_timer;
+    int _forec_update_timer;
+    TimerID _update_timer;
+    RedDrawable* _composit_area;
+    uint64_t _update_mark;
+
+    Point _size;
+    Point _origin;
+    Point _mouse_anchor_point;
+    Point _save_pos;
+    Monitor* _monitor;
+
+    LocalCursor* _default_cursor;
+    LocalCursor* _active_cursor;
+    LocalCursor* _inactive_cursor;
+
+    enum PointerLocation {
+        POINTER_IN_ACTIVE_AREA,
+        POINTER_IN_FRAME_AREA,
+        POINTER_OUTSIDE_WINDOW,
+    };
+    PointerLocation _pointer_location;
+    int _pixel_format_index;
+    EventsLoop::Trigger *_update_interrupt_trigger;
+};
+
+#endif
+
diff --git a/client/screen_layer.cpp b/client/screen_layer.cpp
new file mode 100644
index 00000000..f521b465
--- /dev/null
+++ b/client/screen_layer.cpp
@@ -0,0 +1,200 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "screen_layer.h"
+#include "utils.h"
+#include "screen.h"
+#include "application.h"
+#include "debug.h"
+
+class AttacheLayerEvent: public SyncEvent {
+public:
+    AttacheLayerEvent(ScreenLayer& layer, int screen_id) : _layer (layer), _screen_id (screen_id) {}
+
+    virtual void do_responce(Application& application);
+
+private:
+    ScreenLayer& _layer;
+    int _screen_id;
+};
+
+void AttacheLayerEvent::do_responce(Application& application)
+{
+    AutoRef<RedScreen> screen(application.get_screen(_screen_id));
+    (*screen)->attach_layer(_layer);
+}
+
+class DetacheLayerEvent: public SyncEvent {
+public:
+    DetacheLayerEvent(ScreenLayer& _layer) : _layer (_layer) {}
+
+    virtual void do_responce(Application& application);
+
+private:
+    ScreenLayer& _layer;
+};
+
+void DetacheLayerEvent::do_responce(Application& application)
+{
+    _layer.screen()->detach_layer(_layer);
+}
+
+ScreenLayer::ScreenLayer(int z_order, bool opaque)
+    : _screen (NULL)
+    , _z_order (z_order)
+    , _opaque (opaque)
+    , _using_ogl (false)
+{
+    region_init(&_area);
+    region_init(&_direct_area);
+    region_init(&_composit_area);
+}
+
+ScreenLayer::~ScreenLayer()
+{
+    ASSERT(!_screen);
+    region_destroy(&_area);
+    region_destroy(&_direct_area);
+    region_destroy(&_composit_area);
+}
+
+uint64_t ScreenLayer::invalidate_rect(const Rect& r, bool urgent)
+{
+    return _screen->invalidate(r, urgent);
+}
+
+uint64_t ScreenLayer::invalidate(const Rect& r, bool urgent)
+{
+    if (!_screen) {
+        return 0;
+    }
+    return invalidate_rect(r, urgent);
+}
+
+void ScreenLayer::invalidate(const QRegion& region)
+{
+    if (!_screen) {
+        return;
+    }
+    Rect *r = region.rects;
+    Rect *end = r + region.num_rects;
+    while (r != end) {
+        invalidate_rect(*r++, false);
+    }
+}
+
+void ScreenLayer::invalidate()
+{
+    invalidate(_area);
+}
+
+void ScreenLayer::set_area(const QRegion& area)
+{
+    Lock lock(_area_lock);
+    invalidate();
+    region_destroy(&_area);
+    region_clone(&_area, &area);
+    invalidate();
+}
+
+void ScreenLayer::clear_area()
+{
+    Lock lock(_area_lock);
+    invalidate();
+    region_clear(&_area);
+}
+
+void ScreenLayer::set_rect_area(const Rect& r)
+{
+    Lock lock(_area_lock);
+    invalidate();
+    region_clear(&_area);
+    region_add(&_area, &r);
+    invalidate();
+}
+
+void ScreenLayer::offset_area(int dx, int dy)
+{
+    Lock lock(_area_lock);
+    invalidate();
+    region_offset(&_area, dx, dy);
+    invalidate();
+}
+
+void ScreenLayer::add_rect_area(const Rect& r)
+{
+    Lock lock(_area_lock);
+    region_add(&_area, &r);
+}
+
+void ScreenLayer::remove_rect_area(const Rect& r)
+{
+    Lock lock(_area_lock);
+    invalidate();
+    region_remove(&_area, &r);
+}
+
+void ScreenLayer::begin_update(QRegion& direct_rgn, QRegion& composit_rgn)
+{
+    Lock lock(_area_lock);
+    region_destroy(&_direct_area);
+    region_clone(&_direct_area, &_area);
+    region_and(&_direct_area, &direct_rgn);
+
+    region_destroy(&_composit_area);
+    region_clone(&_composit_area, &_area);
+    region_and(&_composit_area, &composit_rgn);
+
+    region_exclude(&direct_rgn, &_direct_area);
+    if (_opaque) {
+        region_exclude(&composit_rgn, &_composit_area);
+    } else {
+        region_or(&composit_rgn, &_direct_area);
+        region_or(&_composit_area, &_direct_area);
+        region_clear(&_direct_area);
+    }
+}
+
+void ScreenLayer::attach_to_screen(Application& applicaion, int screen_id)
+{
+    if (_screen) {
+        return;
+    }
+    AutoRef<AttacheLayerEvent> event(new AttacheLayerEvent(*this, screen_id));
+    applicaion.push_event(*event);
+    (*event)->wait();
+    if (!(*event)->success()) {
+        THROW("attach failed");
+    }
+    ASSERT(_screen);
+}
+
+void ScreenLayer::detach_from_screen(Application& applicaion)
+{
+    if (!_screen) {
+        return;
+    }
+    AutoRef<DetacheLayerEvent> event(new DetacheLayerEvent(*this));
+    applicaion.push_event(*event);
+    (*event)->wait();
+    if (!(*event)->success()) {
+        THROW("detach failed");
+    }
+    ASSERT(!_screen);
+}
+
diff --git a/client/screen_layer.h b/client/screen_layer.h
new file mode 100644
index 00000000..cbcc5503
--- /dev/null
+++ b/client/screen_layer.h
@@ -0,0 +1,79 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_SCREEN_LAYER
+#define _H_SCREEN_LAYER
+
+#include "threads.h"
+#include "region.h"
+
+class RedScreen;
+class Application;
+
+class ScreenLayer {
+public:
+    ScreenLayer(int z_order, bool opaque);
+    virtual ~ScreenLayer();
+
+    void attach_to_screen(Application& applicaion, int screen_id);
+    void detach_from_screen(Application& applicaion);
+
+    void set_screen(RedScreen* screen) { _screen = screen;}
+    RedScreen* screen() { return _screen; }
+    int z_order() { return _z_order;}
+    void set_area(const QRegion& area);
+    void offset_area(int dx, int dy);
+    void clear_area();
+    void set_rect_area(const Rect& r);
+    void add_rect_area(const Rect& r);
+    void remove_rect_area(const Rect& r);
+    void begin_update(QRegion& direct_rgn, QRegion& composit_rgn);
+    void invalidate();
+    uint64_t invalidate(const Rect& r, bool urgent = false);
+    void invalidate(const QRegion& r);
+
+    virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc) {}
+
+    void set_using_ogl(bool val) {_using_ogl = val;}
+    bool using_ogl() {return _using_ogl;}
+    virtual void on_size_changed() {}
+
+    virtual void pre_migrate() { }
+    virtual void post_migrate() { }
+
+    QRegion& area() { return _area;}
+    QRegion& direct_area() { return _direct_area;}
+    QRegion& composit_area() { return _composit_area;}
+
+    virtual void on_update_completion(uint64_t mark) {}
+
+private:
+    uint64_t invalidate_rect(const Rect& r, bool urgent);
+
+private:
+    RedScreen* _screen;
+    int _z_order;
+    bool _opaque;
+    bool _using_ogl;
+    Mutex _area_lock;
+    QRegion _area;
+    QRegion _direct_area;
+    QRegion _composit_area;
+};
+
+#endif
+
diff --git a/client/shared_cache.hpp b/client/shared_cache.hpp
new file mode 100644
index 00000000..ee966386
--- /dev/null
+++ b/client/shared_cache.hpp
@@ -0,0 +1,152 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_SHARED_CACHE
+#define _H_SHARED_CACHE
+
+#include "utils.h"
+#include "threads.h"
+
+/*class SharedCache::Treat {
+    T* get(T*);
+    void release(T*);
+    const char* name();
+};*/
+
+template <class T, class Treat, int HASH_SIZE>
+class SharedCache {
+public:
+    SharedCache()
+        : _aborting (false)
+    {
+        memset(_hash, 0, sizeof(_hash));
+    }
+
+    ~SharedCache()
+    {
+        clear();
+    }
+
+    void add(uint64_t id, T* data)
+    {
+        Lock lock(_lock);
+        Item** item = &_hash[key(id)];
+
+        while (*item) {
+            if ((*item)->id == id) {
+                (*item)->refs++;
+                return;
+            }
+            item = &(*item)->next;
+        }
+        *item = new Item(id, data);
+        _new_item_cond.notify_all();
+    }
+
+    T* get(uint64_t id)
+    {
+        Lock lock(_lock);
+        Item* item = _hash[key(id)];
+
+        for (;;) {
+            if (!item) {
+                if (_aborting) {
+                    THROW("%s aborting", Treat::name());
+                }
+                _new_item_cond.wait(lock);
+                item = _hash[key(id)];
+                continue;
+            }
+
+            if (item->id != id) {
+                item = item->next;
+                continue;
+            }
+
+            return Treat::get(item->data);
+        }
+    }
+
+    void remove(uint64_t id)
+    {
+        Lock lock(_lock);
+        Item** item = &_hash[key(id)];
+
+        while (*item) {
+            if ((*item)->id == id) {
+                if (!--(*item)->refs) {
+                    Item *rm_item = *item;
+                    *item = rm_item->next;
+                    delete rm_item;
+                }
+                return;
+            }
+            item = &(*item)->next;
+        }
+        THROW("%s id %lu, not found", Treat::name(), id);
+    }
+
+    void clear()
+    {
+        Lock lock(_lock);
+        for (int i = 0; i < HASH_SIZE; i++) {
+            while (_hash[i]) {
+                Item *item = _hash[i];
+                _hash[i] = item->next;
+                delete item;
+            }
+        }
+    }
+
+    void abort()
+    {
+        Lock lock(_lock);
+        _aborting = true;
+        _new_item_cond.notify_all();
+    }
+
+private:
+    inline uint32_t key(uint64_t id) {return uint32_t(id) % HASH_SIZE;}
+
+private:
+    class Item {
+    public:
+        Item(uint64_t in_id, T* data)
+            : id (in_id)
+            , refs (1)
+            , next (NULL)
+            , data (Treat::get(data)) {}
+
+        ~Item()
+        {
+            Treat::release(data);
+        }
+
+        uint64_t id;
+        int refs;
+        Item* next;
+        T* data;
+    };
+
+    Item* _hash[HASH_SIZE];
+    Mutex _lock;
+    Condition _new_item_cond;
+    bool _aborting;
+};
+
+#endif
+
diff --git a/client/threads.cpp b/client/threads.cpp
new file mode 100644
index 00000000..20774f3a
--- /dev/null
+++ b/client/threads.cpp
@@ -0,0 +1,125 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "threads.h"
+#include "utils.h"
+#include "debug.h"
+#ifdef WIN32
+#include <sys/timeb.h>
+#endif
+
+Thread::Thread(thread_main_t thread_main, void* opaque)
+{
+    int r = pthread_create(&_thread, NULL, thread_main, opaque);
+    if (r) {
+        THROW("failed %d", r);
+    }
+}
+
+void Thread::join()
+{
+    pthread_join(_thread, NULL);
+}
+
+static inline void rel_time(struct timespec& time, uint64_t delta_nano)
+{
+#ifdef WIN32
+    struct _timeb now;
+    _ftime_s(&now);
+    time.tv_sec = now.time;
+    time.tv_nsec = now.millitm * 1000 * 1000;
+#else
+    clock_gettime(CLOCK_MONOTONIC, &time);
+#endif
+    delta_nano += (uint64_t)time.tv_sec * 1000 * 1000 * 1000;
+    delta_nano += time.tv_nsec;
+    time.tv_sec = long(delta_nano / (1000 * 1000 * 1000));
+    time.tv_nsec = long(delta_nano % (1000 * 1000 * 1000));
+}
+
+void Lock::timed_lock(uint64_t timout_nano)
+{
+    struct timespec time;
+    int r;
+
+    rel_time(time, timout_nano);
+    if ((r = pthread_mutex_timedlock(_mutex.get(), &time))) {
+        _locked = false;
+        if (r != ETIMEDOUT) {
+            THROW("failed %d", r);
+        }
+        return;
+    }
+    _locked = true;
+}
+
+Condition::Condition()
+{
+#ifdef WIN32
+    pthread_cond_init(&_condition, NULL);
+#else
+    pthread_condattr_t attr;
+    pthread_condattr_init(&attr);
+    int r;
+    if ((r = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))) {
+        THROW("set clock failed %d", r);
+    }
+    pthread_cond_init(&_condition, &attr);
+    pthread_condattr_destroy(&attr);
+#endif
+}
+
+bool Condition::timed_wait(Lock& lock, uint64_t nano)
+{
+    struct timespec time;
+    rel_time(time, nano);
+    int r = pthread_cond_timedwait(&_condition, lock.get(), &time);
+    if (r) {
+        if (r != ETIMEDOUT) {
+            THROW("failed %d", r);
+        }
+        return false;
+    }
+    return true;
+}
+
+Mutex::Mutex(Type type)
+{
+    pthread_mutexattr_t attr;
+
+    pthread_mutexattr_init(&attr);
+    if (type == NORMAL) {
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+    } else if (type == RECURSIVE) {
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    } else {
+        THROW("invalid type %d", type);
+    }
+
+    int r;
+    if ((r = pthread_mutex_init(&_mutex, &attr))) {
+        THROW("int failed %d", r);
+    }
+    pthread_mutexattr_destroy(&attr);
+}
+
+Mutex::~Mutex()
+{
+    pthread_mutex_destroy(&_mutex);
+}
+
diff --git a/client/threads.h b/client/threads.h
new file mode 100644
index 00000000..b6bce98c
--- /dev/null
+++ b/client/threads.h
@@ -0,0 +1,135 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_THREADS
+#define _H_THREADS
+
+#include "pthread.h"
+#include "atomic_count.h"
+
+class Thread {
+public:
+    typedef void* (*thread_main_t)(void*);
+
+    Thread(thread_main_t thread_main, void* opaque);
+    void join();
+
+private:
+    pthread_t _thread;
+};
+
+class Mutex {
+public:
+    enum Type {
+        NORMAL,
+        RECURSIVE,
+    };
+
+    Mutex(Type = NORMAL);
+    virtual ~Mutex();
+
+private:
+    friend class Lock;
+    pthread_mutex_t* get() {return &_mutex;}
+
+private:
+    pthread_mutex_t _mutex;
+};
+
+class Lock {
+public:
+    Lock(Mutex& mutex)
+        : _locked (true)
+        , _mutex (mutex)
+    {
+        pthread_mutex_lock(_mutex.get());
+    }
+
+    Lock(Mutex& mutex, uint64_t timout_nano)
+        : _mutex (mutex)
+    {
+        if (!pthread_mutex_trylock(_mutex.get())) {
+            _locked = true;
+            return;
+        }
+        timed_lock(timout_nano);
+    }
+
+    ~Lock()
+    {
+        unlock();
+    }
+
+    void unlock()
+    {
+        if (_locked) {
+            pthread_mutex_unlock(_mutex.get());
+            _locked = false;
+        }
+    }
+
+    bool is_locked() { return _locked;}
+
+private:
+    friend class Condition;
+    pthread_mutex_t* get() {return _mutex.get();}
+    void timed_lock(uint64_t timout_nano);
+
+private:
+    bool _locked;
+    Mutex& _mutex;
+};
+
+class RecurciveMutex: public Mutex {
+public:
+    RecurciveMutex() : Mutex(Mutex::RECURSIVE) {}
+};
+
+typedef Lock RecurciveLock;
+class Condition {
+public:
+    Condition();
+
+    ~Condition()
+    {
+        pthread_cond_destroy(&_condition);
+    }
+
+    void notify_one()
+    {
+        pthread_cond_signal(&_condition);
+    }
+
+    void notify_all()
+    {
+        pthread_cond_broadcast(&_condition);
+    }
+
+    void wait(Lock& lock)
+    {
+        pthread_cond_wait(&_condition, lock.get());
+    }
+
+    bool timed_wait(Lock& lock, uint64_t nano);
+
+private:
+    pthread_cond_t _condition;
+};
+
+
+#endif
+
diff --git a/client/utils.cpp b/client/utils.cpp
new file mode 100644
index 00000000..29201743
--- /dev/null
+++ b/client/utils.cpp
@@ -0,0 +1,39 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include "utils.h"
+
+void string_printf(std::string& str, const char* format, ...)
+{
+    va_list ap;
+    va_start(ap, format);
+    string_vprintf(str, format, ap);
+    va_end(ap);
+}
+
+void wstring_printf(std::wstring& str, const wchar_t* format, ...)
+{
+    va_list ap;
+    va_start(ap, format);
+    wstring_vprintf(str, format, ap);
+    va_end(ap);
+}
+
diff --git a/client/utils.h b/client/utils.h
new file mode 100644
index 00000000..4be75281
--- /dev/null
+++ b/client/utils.h
@@ -0,0 +1,151 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_UTILS
+#define _H_UTILS
+
+#include "common.h"
+#include "red_error_codes.h"
+
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+
+class Exception: public std::exception {
+public:
+    Exception(const std::string& str, int error_code) : _mess (str), _erro_code (error_code) {}
+    Exception(const std::string& str) : _mess (str) { _erro_code = SPICEC_ERROR_CODE_ERROR;}
+    virtual ~Exception() throw () {}
+    virtual const char* what() const throw () {return _mess.c_str();}
+    int get_error_code() {return _erro_code;}
+
+private:
+    std::string _mess;
+    int _erro_code;
+};
+
+#define THROW(format, ...)  {                                   \
+    std::string exption_string;                                 \
+    string_printf(exption_string, format, ## __VA_ARGS__ );     \
+    throw Exception(exption_string);                            \
+}
+
+#define THROW_ERR(err, format, ...)  {                          \
+    std::string exption_string;                                 \
+    string_printf(exption_string, format, ## __VA_ARGS__ );     \
+    throw Exception(exption_string, err);                       \
+}
+
+
+template <class T>
+class AutoRef {
+public:
+    AutoRef() : _obj (NULL) {}
+    AutoRef(T* obj) : _obj (obj) {}
+    ~AutoRef() { if (_obj) _obj->unref();}
+    T* operator * () {return _obj;}
+
+    void reset(T* obj)
+    {
+        if (_obj) {
+            _obj->unref();
+        }
+        _obj = obj;
+    }
+
+    T* release()
+    {
+        T* ret = _obj;
+        _obj = NULL;
+        return ret;
+    }
+
+private:
+    T* _obj;
+};
+
+static inline int test_bit(const void* addr, int bit)
+{
+    return !!(((uint32_t*)addr)[bit >> 5] & (1 << (bit & 0x1f)));
+}
+
+static inline int test_bit_be(const void* addr, int bit)
+{
+    return !!(((uint8_t*)addr)[bit >> 3] & (0x80 >> (bit & 0x07)));
+}
+
+static inline void set_bit(const void* addr, int bit)
+{
+    ((uint8_t*)addr)[bit >> 5] |= (0x1 << (bit & 0x1f));
+}
+
+static inline void set_bit_be(const void* addr, int bit)
+{
+    ((uint8_t*)addr)[bit >> 3] |= (0x80 >> (bit & 0x07));
+}
+
+void string_vprintf(std::string& str, const char* format, va_list ap);
+void string_printf(std::string& str, const char *format, ...);
+void wstring_vprintf(std::wstring& str, const wchar_t* format, va_list ap);
+void wstring_printf(std::wstring& str, const wchar_t *format, ...);
+
+template<class T>
+class FreeObject {
+public:
+    void operator () (T p) { delete p;}
+};
+
+template<class T, class FreeRes = FreeObject<T> >
+class _AutoRes {
+public:
+    _AutoRes() : _res (NULL) {}
+    _AutoRes(T* res) : _res (res) {}
+    ~_AutoRes() { set(NULL); }
+
+    void set(T* res) {if (_res) _free_res(_res); _res = res; }
+    T* get() {return _res;}
+    T* operator -> () { return _res;}
+    T* release() {T* tmp = _res; _res = NULL; return tmp; }
+    bool valid() { return !!_res; }
+
+private:
+    _AutoRes(const _AutoRes&);
+    _AutoRes& operator = (const _AutoRes&);
+
+private:
+    T* _res;
+    FreeRes _free_res;
+};
+
+template<class T>
+class AutoArray {
+public:
+    AutoArray() : _array (NULL) {}
+    AutoArray(T* array) : _array (array) {}
+    ~AutoArray() { delete[] _array;}
+
+    void set(T* array) { delete[] _array; _array = array;}
+    T* get() {return _array;}
+    T* release() {T* tmp = _array; _array = NULL; return tmp; }
+    T& operator [] (int i) {return _array[i];}
+
+private:
+    T* _array;
+};
+
+#endif
+
diff --git a/client/windows/atomic_count.h b/client/windows/atomic_count.h
new file mode 100644
index 00000000..d7a057a3
--- /dev/null
+++ b/client/windows/atomic_count.h
@@ -0,0 +1,42 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_ATOMIC_COUNT
+#define _H_ATOMIC_COUNT
+
+class AtomicCount {
+public:
+    AtomicCount(uint32_t count = 0) : _count (count) {}
+
+    uint32_t operator ++ ()
+    {
+        return InterlockedIncrement(&_count);
+    }
+
+    uint32_t operator -- ()
+    {
+        return InterlockedDecrement(&_count);
+    }
+
+    operator uint32_t () { return _count;}
+
+private:
+    LONG _count;
+};
+
+#endif
+
diff --git a/client/windows/events_loop_p.cpp b/client/windows/events_loop_p.cpp
new file mode 100644
index 00000000..7329d161
--- /dev/null
+++ b/client/windows/events_loop_p.cpp
@@ -0,0 +1,158 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "events_loop.h"
+#include "debug.h"
+#include "utils.h"
+
+
+EventsLoop::EventsLoop()
+{
+}
+
+EventsLoop::~EventsLoop()
+{
+}
+
+void EventsLoop::run()
+{
+    for (;;) {
+        run_once();
+    }
+}
+
+void EventsLoop::run_once(int timeout_milli)
+{
+    DWORD wait_res = WaitForMultipleObjects(_handles.size(), &_handles[0], FALSE, timeout_milli);
+    if (wait_res == WAIT_FAILED) {
+        THROW("wait failed");
+    }
+    int event_index = wait_res - WAIT_OBJECT_0;
+    if (event_index < 0 || event_index >= (int)_events.size()) {
+        THROW("invalid event id");
+    }
+    _events[event_index]->action();
+}
+
+void EventsLoop::add_socket(Socket& socket)
+{
+    HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if (!event) {
+        THROW("create event failed");
+    }
+    if (WSAEventSelect(socket.get_socket(), event, FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR) {
+        CloseHandle(event);
+        THROW("event select failed");
+    }
+    int size = _events.size();
+    _events.resize(size + 1);
+    _handles.resize(size + 1);
+    _events[size] = &socket;
+    _handles[size] = event;
+}
+
+void EventsLoop::remove_socket(Socket& socket)
+{
+    int size = _events.size();
+    for (int i = 0; i < size; i++) {
+        if (_events[i] == &socket) {
+            if (WSAEventSelect(socket.get_socket(), NULL, 0) == SOCKET_ERROR) {
+                THROW("event select failed");
+            }
+            u_long arg = 0;
+            if (ioctlsocket(socket.get_socket(), FIONBIO, &arg) == SOCKET_ERROR) {
+                THROW("set blocking mode failed");
+            }
+            CloseHandle(_handles[i]);
+            for (i++; i < size; i++) {
+                _events[i - 1] = _events[i];
+                _handles[i - 1] = _handles[i];
+            }
+            _events.resize(size - 1);
+            _handles.resize(size - 1);
+            return;
+        }
+    }
+    THROW("socket not found");
+}
+
+void EventsLoop::add_trigger(Trigger& trigger)
+{
+    int size = _events.size();
+    _events.resize(size + 1);
+    _handles.resize(size + 1);
+    _events[size] = &trigger;
+    _handles[size] = trigger.get_handle();
+}
+
+void EventsLoop::remove_trigger(Trigger& trigger)
+{
+    int size = _events.size();
+    for (int i = 0; i < size; i++) {
+        if (_events[i] == &trigger) {
+            for (i++; i < size; i++) {
+                _events[i - 1] = _events[i];
+                _handles[i - 1] = _handles[i];
+            }
+            _events.resize(size - 1);
+            _handles.resize(size - 1);
+            return;
+        }
+    }
+    THROW("trigger not found");
+}
+
+EventsLoop::Trigger::Trigger()
+{
+    if (!(event = CreateEvent(NULL, FALSE, FALSE, NULL))) {
+        THROW("create event failed");
+    }
+}
+
+EventsLoop::Trigger::~Trigger()
+{
+    CloseHandle(event);
+}
+
+void EventsLoop::Trigger::trigger()
+{
+    if (!SetEvent(event)) {
+        THROW("set event failed");
+    }
+}
+
+void EventsLoop::Trigger::reset()
+{
+    if (!ResetEvent(event)) {
+        THROW("set event failed");
+    }
+}
+
+void EventsLoop::Trigger::action()
+{
+    on_event();
+}
+
+void EventsLoop::add_file(File& file)
+{
+}
+
+void EventsLoop::remove_file(File& file)
+{
+}
+
diff --git a/client/windows/events_loop_p.h b/client/windows/events_loop_p.h
new file mode 100644
index 00000000..8361398d
--- /dev/null
+++ b/client/windows/events_loop_p.h
@@ -0,0 +1,42 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_EVENTS_LOOP_P
+#define _H_EVENTS_LOOP_P
+
+#include "common.h"
+
+#include <vector>
+
+class EventSource;
+
+class EventsLoop_p {
+public:
+    std::vector<EventSource*> _events;
+    std::vector<HANDLE> _handles;
+};
+
+class Trigger_p {
+public:
+    HANDLE get_handle() { return event;}
+
+public:
+    HANDLE event;
+};
+
+#endif
+
diff --git a/client/windows/main.cpp b/client/windows/main.cpp
new file mode 100644
index 00000000..a1575e90
--- /dev/null
+++ b/client/windows/main.cpp
@@ -0,0 +1,124 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <fstream>
+#include <windows.h>
+extern "C" {
+#include "pthread.h"
+}
+
+//#define OPEN_CONSOLE
+#ifdef OPEN_CONSOLE
+#include <io.h>
+#include <conio.h>
+#endif
+
+#include "application.h"
+#include "debug.h"
+#include "utils.h"
+
+HINSTANCE instance = NULL;
+
+static void init_winsock()
+{
+    WSADATA wsaData;
+    int res;
+
+    if ((res = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0) {
+        THROW("WSAStartup failed %d", res);
+    }
+}
+
+char* version_string = "???";
+static char _version_string[40];
+
+static void init_version_string()
+{
+    DWORD handle;
+    DWORD verrsion_inf_size = GetFileVersionInfoSizeA(__argv[0], &handle);
+    if (verrsion_inf_size == 0) {
+        return;
+    }
+    AutoArray<uint8_t> info_buf (new uint8_t[verrsion_inf_size]);
+    if (!GetFileVersionInfoA(__argv[0], handle, verrsion_inf_size, info_buf.get())) {
+         return;
+    }
+    UINT size;
+    VS_FIXEDFILEINFO *file_info;
+    if (!VerQueryValueA(info_buf.get(), "\\", (VOID**)&file_info, &size) ||
+            size < sizeof(VS_FIXEDFILEINFO)) {
+        return;
+    }
+    sprintf(_version_string, "%d.%d.%d.%d",
+        file_info->dwFileVersionMS >> 16,
+        file_info->dwFileVersionMS & 0x0ffff,
+        file_info->dwFileVersionLS >> 16,
+        file_info->dwFileVersionLS & 0x0ffff);
+    version_string = _version_string;
+}
+
+int WINAPI WinMain(HINSTANCE hInstance,
+                   HINSTANCE hPrevInstance,
+                   LPSTR lpCmdLine,
+                   int nCmdShow)
+{
+    int exit_val;
+
+    instance = hInstance;
+
+    try {
+        init_version_string();
+#ifdef OPEN_CONSOLE
+        AllocConsole();
+        HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+        int hConHandle = _open_osfhandle((intptr_t)h, _O_TEXT);
+        FILE * fp = _fdopen(hConHandle, "w");
+        *stdout = *fp;
+
+        h = GetStdHandle(STD_INPUT_HANDLE);
+        hConHandle = _open_osfhandle((intptr_t)h, _O_TEXT);
+        fp = _fdopen(hConHandle, "r");
+        *stdin = *fp;
+
+        h = GetStdHandle(STD_ERROR_HANDLE);
+        hConHandle = _open_osfhandle((intptr_t)h, _O_TEXT);
+        fp = _fdopen(hConHandle, "w");
+        *stderr = *fp;
+#endif
+        pthread_win32_process_attach_np();
+        init_winsock();
+        exit_val = Application::main(__argc, __argv, version_string);
+        LOG_INFO("Spice client terminated (exitcode = %d)", exit_val);
+    } catch (Exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+        exit_val = e.get_error_code();
+    } catch (std::exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+        exit_val = SPICEC_ERROR_CODE_ERROR;
+    } catch (...) {
+        LOG_ERROR("unhandled exception");
+        exit_val = SPICEC_ERROR_CODE_ERROR;
+    }
+    log4cpp::Category::shutdown();
+#ifdef OPEN_CONSOLE
+    _getch();
+#endif
+    pthread_win32_process_detach_np();
+    return exit_val;
+}
+
diff --git a/client/windows/my_getopt.cpp b/client/windows/my_getopt.cpp
new file mode 100644
index 00000000..228dc006
--- /dev/null
+++ b/client/windows/my_getopt.cpp
@@ -0,0 +1,20 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "../../common/win/my_getopt-1.5/my_getopt.c"
+
diff --git a/client/windows/named_pipe.cpp b/client/windows/named_pipe.cpp
new file mode 100644
index 00000000..f33c476e
--- /dev/null
+++ b/client/windows/named_pipe.cpp
@@ -0,0 +1,227 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "named_pipe.h"
+#include "utils.h"
+#include "debug.h"
+
+PipeBuffer::PipeBuffer(HANDLE pipe)
+    : _handler (NULL)
+    , _pipe (pipe)
+    , _start (0)
+    , _end (0)
+    , _pending (false)
+{
+    ZeroMemory(&_overlap, sizeof(_overlap));
+    _overlap.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    _event_handle = _overlap.hEvent;
+    WinPlatform::add_event(*this);
+}
+
+PipeBuffer::~PipeBuffer()
+{
+    WinPlatform::remove_event(*this);
+    CloseHandle(_event_handle);
+}
+
+DWORD PipeBuffer::get_overlapped_bytes()
+{
+    DWORD bytes = 0;
+
+    if (!GetOverlappedResult(_pipe, &_overlap, &bytes, FALSE) || bytes == 0) {
+        _pending = false;
+        _handler->on_data();
+    }
+    return bytes;
+}
+
+int32_t PipeReader::read(uint8_t *buf, int32_t size)
+{
+    ASSERT(buf && size >= 0);
+
+    if (_start < _end) {
+        int32_t bytes_read = 0;
+        bytes_read = MIN(_end - _start, (uint32_t)size);
+        CopyMemory(buf, _data + _start, bytes_read);
+        _start += bytes_read;
+        if (_start == _end) {
+            _start = _end = 0;
+        }
+        return bytes_read;
+    }
+    if (_pending) {
+        return 0;
+    }
+    if (!ReadFile(_pipe, _data + _end, sizeof(_data) - _end, NULL, &_overlap) &&
+                                              GetLastError() != ERROR_IO_PENDING) {
+        DBG(0, "ReadFile() failed %u", GetLastError());
+        return -1;
+    }
+    _pending = true;
+    return 0;
+}
+
+void PipeReader::on_event()
+{
+    ASSERT(_pending);
+    DWORD bytes = get_overlapped_bytes();
+
+    if (!bytes) {
+        return;
+    }
+    _end += bytes;
+    _pending = false;
+    _handler->on_data();
+}
+
+int32_t PipeWriter::write(const uint8_t *buf, int32_t size)
+{
+    int32_t bytes_written = 0;
+    ASSERT(buf && size >= 0);
+
+    if (!_pending && _start == _end) {
+        _start = _end = 0;
+    }
+    if (_end < sizeof(_data)) {
+        bytes_written = MIN(sizeof(_data) - _end, (uint32_t)size);
+        CopyMemory(_data + _end, buf, bytes_written);
+        _end += bytes_written;
+    }
+    if (!_pending && _start < _end) {
+        if (!WriteFile(_pipe, _data + _start, _end - _start, NULL, &_overlap) &&
+                                              GetLastError() != ERROR_IO_PENDING) {
+            DBG(0, "WriteFile() failed %u", GetLastError());
+            return -1;
+        }
+        _pending = true;
+    }
+    return bytes_written;
+}
+
+void PipeWriter::on_event()
+{
+    ASSERT(_pending);
+    DWORD bytes = get_overlapped_bytes();
+    if (!bytes) {
+        return;
+    }
+    _start += bytes;
+    _pending = false;
+    if (_start == sizeof(_data)) {
+        _handler->on_data();
+    }
+}
+
+WinConnection::WinConnection(HANDLE pipe)
+    : _pipe (pipe)
+    , _writer (pipe)
+    , _reader (pipe)
+{
+}
+
+WinConnection::~WinConnection()
+{
+    if (!DisconnectNamedPipe(_pipe)) {
+        DBG(0, "DisconnectNamedPipe failed %d", GetLastError());
+    }
+    CloseHandle(_pipe);
+}
+
+int32_t WinConnection::read(uint8_t *buf, int32_t size)
+{
+    return _reader.read(buf, size);
+}
+
+int32_t WinConnection::write(const uint8_t *buf, int32_t size)
+{
+    return _writer.write(buf, size);
+}
+
+void WinConnection::set_handler(NamedPipe::ConnectionInterface* handler)
+{
+    _reader.set_handler(handler);
+    _writer.set_handler(handler);
+}
+
+WinListener::WinListener(const char *name, NamedPipe::ListenerInterface &listener_interface)
+    : _listener_interface (listener_interface)
+    , _pipe (0)
+{
+    _pipename = new TCHAR[PIPE_MAX_NAME_LEN];
+    swprintf_s(_pipename, PIPE_MAX_NAME_LEN, L"%s%S", PIPE_PREFIX, name);
+    ZeroMemory(&_overlap, sizeof(_overlap));
+    _overlap.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    _event_handle = _overlap.hEvent;
+    WinPlatform::add_event(*this);
+    create_pipe();
+}
+
+WinListener::~WinListener()
+{
+    CancelIo(_pipe);
+    WinPlatform::remove_event(*this);
+    CloseHandle(_event_handle);
+    delete[] _pipename;
+}
+
+void WinListener::on_event()
+{
+    DWORD bytes;
+
+    if (!GetOverlappedResult(_pipe, &_overlap, &bytes, FALSE)) {
+        DBG(0, "GetOverlappedResult() failed %u", GetLastError());
+        return;
+    }
+    DBG(0, "Pipe connected 0x%p", _pipe);
+    WinConnection *con = new WinConnection(_pipe);
+    NamedPipe::ConnectionInterface &con_interface = _listener_interface.create();
+    con->set_handler(&con_interface);
+    con_interface.bind((NamedPipe::ConnectionRef)con);
+    create_pipe();
+}
+
+void WinListener::create_pipe()
+{
+    _pipe = CreateNamedPipe(_pipename, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+                            PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+                            PIPE_UNLIMITED_INSTANCES, PIPE_BUF_SIZE, PIPE_BUF_SIZE,
+                            PIPE_TIMEOUT, NULL);
+    if (_pipe == INVALID_HANDLE_VALUE) {
+        THROW("CreateNamedPipe() failed %u", GetLastError());
+    }
+    if (ConnectNamedPipe(_pipe, &_overlap)) {
+        THROW("ConnectNamedPipe() is not pending");
+    }
+    switch (GetLastError()) {
+    case ERROR_IO_PENDING:
+        DBG(0, "Pipe waits for connection");
+        break;
+    case ERROR_PIPE_CONNECTED: {
+        DBG(0, "Pipe already connected");
+        WinConnection *con = new WinConnection(_pipe);
+        NamedPipe::ConnectionInterface &con_interface = _listener_interface.create();
+        con->set_handler(&con_interface);
+        con_interface.bind((NamedPipe::ConnectionRef)con);
+        create_pipe();
+        break;
+    }
+    default:
+        THROW("ConnectNamedPipe() failed %u", GetLastError());
+    }
+}
+
diff --git a/client/windows/named_pipe.h b/client/windows/named_pipe.h
new file mode 100644
index 00000000..578c34d2
--- /dev/null
+++ b/client/windows/named_pipe.h
@@ -0,0 +1,94 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_NAMED_PIPE
+#define _H_NAMED_PIPE
+
+#include <windows.h>
+#include "platform.h"
+#include "win_platform.h"
+
+#define PIPE_TIMEOUT 5000
+#define PIPE_BUF_SIZE 8192
+#define PIPE_MAX_NAME_LEN 256
+#define PIPE_PREFIX TEXT("\\\\.\\pipe\\")
+
+class WinConnection;
+
+class PipeBuffer: public EventOwner {
+public:
+    PipeBuffer(HANDLE pipe);
+    ~PipeBuffer();
+    void set_handler(NamedPipe::ConnectionInterface* handler) { _handler = handler;}
+    DWORD get_overlapped_bytes();
+
+protected:
+    NamedPipe::ConnectionInterface *_handler;
+    OVERLAPPED _overlap;
+    HANDLE _pipe;
+    uint32_t _start;
+    uint32_t _end;
+    uint8_t _data[PIPE_BUF_SIZE];
+    bool _pending;
+};
+
+class PipeReader: public PipeBuffer {
+public:
+    PipeReader(HANDLE pipe) : PipeBuffer(pipe) {}
+    int32_t read(uint8_t *buf, int32_t size);
+    void on_event();
+};
+
+class PipeWriter: public PipeBuffer {
+public:
+    PipeWriter(HANDLE pipe) : PipeBuffer(pipe) {}
+    int32_t write(const uint8_t *buf, int32_t size);
+    void on_event();
+};
+
+class WinConnection {
+public:
+    WinConnection(HANDLE pipe);
+    ~WinConnection();
+    int32_t read(uint8_t *buf, int32_t size);
+    int32_t write(const uint8_t *buf, int32_t size);
+    void set_handler(NamedPipe::ConnectionInterface* handler);
+
+private:
+    HANDLE _pipe;
+    PipeWriter _writer;
+    PipeReader _reader;
+};
+
+class WinListener: public EventOwner {
+public:
+    WinListener(const char *name, NamedPipe::ListenerInterface &listener_interface);
+    ~WinListener();
+    void on_event();
+
+private:
+    void create_pipe();
+
+private:
+    TCHAR *_pipename;
+    NamedPipe::ListenerInterface &_listener_interface;
+    OVERLAPPED _overlap;
+    HANDLE _pipe;
+};
+
+#endif
+
diff --git a/client/windows/pixels_source.cpp b/client/windows/pixels_source.cpp
new file mode 100644
index 00000000..6d210f09
--- /dev/null
+++ b/client/windows/pixels_source.cpp
@@ -0,0 +1,108 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "pixels_source.h"
+#include "pixels_source_p.h"
+#include "platform_utils.h"
+#include "threads.h"
+#include "debug.h"
+
+
+static Point get_bitmap_size(HDC dc)
+{
+    BITMAP bitmap_info;
+    Point size;
+
+    GetObject(GetCurrentObject(dc, OBJ_BITMAP), sizeof(bitmap_info), &bitmap_info);
+
+    size.x = bitmap_info.bmWidth;
+    size.y = bitmap_info.bmHeight;
+    return size;
+}
+
+PixelsSource::PixelsSource()
+{
+    ASSERT(sizeof(_opaque) >= sizeof(PixelsSource_p));
+    _origin.x = _origin.y = 0;
+    memset(_opaque, 0, sizeof(_opaque));
+    PixelsSource_p* p_data = (PixelsSource_p*)_opaque;
+    p_data->_mutex = new Mutex();
+}
+
+PixelsSource::~PixelsSource()
+{
+    PixelsSource_p* p_data = (PixelsSource_p*)_opaque;
+    delete p_data->_mutex;
+}
+
+struct ResImage_p {
+    PixelsSource_p source_p;
+    HBITMAP prev_bitmap;
+};
+
+
+ImageFromRes::ImageFromRes(int res_id)
+{
+    AutoDC dc(create_compatible_dc());
+    ((ResImage_p*)get_opaque())->prev_bitmap = (HBITMAP)SelectObject(dc.get(),
+                                                                     get_bitmap_res(res_id));
+    ((ResImage_p*)get_opaque())->source_p.dc = dc.release();
+}
+
+ImageFromRes::~ImageFromRes()
+{
+    HDC dc = ((ResImage_p*)get_opaque())->source_p.dc;
+    if (dc) {
+        HGDIOBJ bitmap = SelectObject(dc, ((ResImage_p*)get_opaque())->prev_bitmap);
+        DeleteObject(bitmap);
+        DeleteDC(dc);
+    }
+}
+
+Point ImageFromRes::get_size()
+{
+    ResImage_p* p_data = (ResImage_p*)get_opaque();
+    Lock lock(*p_data->source_p._mutex);
+    return get_bitmap_size(p_data->source_p.dc);
+}
+
+AlphaImageFromRes::AlphaImageFromRes(int res_id)
+{
+    AutoDC dc(create_compatible_dc());
+    ((ResImage_p*)get_opaque())->prev_bitmap = (HBITMAP)SelectObject(dc.get(),
+                                                                     get_alpha_bitmap_res(res_id));
+    ((ResImage_p*)get_opaque())->source_p.dc = dc.release();
+}
+
+AlphaImageFromRes::~AlphaImageFromRes()
+{
+    HDC dc = ((ResImage_p*)get_opaque())->source_p.dc;
+    if (dc) {
+        HGDIOBJ bitmap = SelectObject(dc, ((ResImage_p*)get_opaque())->prev_bitmap);
+        DeleteObject(bitmap);
+        DeleteDC(dc);
+    }
+}
+
+Point AlphaImageFromRes::get_size()
+{
+    ResImage_p* p_data = (ResImage_p*)get_opaque();
+    Lock lock(*p_data->source_p._mutex);
+    return get_bitmap_size(p_data->source_p.dc);
+}
+
diff --git a/client/windows/pixels_source_p.h b/client/windows/pixels_source_p.h
new file mode 100644
index 00000000..eb646395
--- /dev/null
+++ b/client/windows/pixels_source_p.h
@@ -0,0 +1,29 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PIXELE_SOURSR_P
+#define _H_PIXELE_SOURSR_P
+
+class Mutex;
+
+struct PixelsSource_p {
+    HDC dc;
+    Mutex* _mutex;
+};
+
+#endif
+
diff --git a/client/windows/platform.cpp b/client/windows/platform.cpp
new file mode 100644
index 00000000..773fa614
--- /dev/null
+++ b/client/windows/platform.cpp
@@ -0,0 +1,786 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+
+#include "platform.h"
+#include "win_platform.h"
+#include "utils.h"
+#include "threads.h"
+#include "debug.h"
+#include "monitor.h"
+#include "record.h"
+#include "playback.h"
+#include "cursor.h"
+#include "named_pipe.h"
+
+#define WM_USER_WAKEUP WM_USER
+#define NUM_TIMERS 100
+
+int gdi_handlers = 0;
+extern HINSTANCE instance;
+
+class DefaultEventListener: public Platform::EventListener {
+public:
+    virtual void on_app_activated() {}
+    virtual void on_app_deactivated() {}
+    virtual void on_monitors_change() {}
+};
+
+static DefaultEventListener default_event_listener;
+static Platform::EventListener* event_listener = &default_event_listener;
+static HWND paltform_win;
+static HANDLE main_tread;
+
+struct Timer {
+    TimerID id;
+    timer_proc_t proc;
+    void* opaque;
+    Timer *next;
+};
+
+Timer timers[NUM_TIMERS];
+Timer* free_timers = NULL;
+Mutex timers_lock;
+
+static void free_timer(Timer* timer)
+{
+    Lock lock(timers_lock);
+    timer->proc = NULL;
+    timer->next = free_timers;
+    free_timers = timer;
+}
+
+static void init_timers()
+{
+    for (int i = 0; i < NUM_TIMERS; i++) {
+        timers[i].id = i;
+        free_timer(&timers[i]);
+    }
+}
+
+static Timer* alloc_timer()
+{
+    Timer* timer;
+
+    Lock lock(timers_lock);
+    if (!(timer = free_timers)) {
+        return NULL;
+    }
+
+    free_timers = free_timers->next;
+    return timer;
+}
+
+static LRESULT CALLBACK PlatformWinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch (message) {
+    case WM_TIMER: {
+        TimerID id = wParam - 1;
+        ASSERT(id < NUM_TIMERS);
+        Timer* timer = &timers[id];
+        timer->proc(timer->opaque, id);
+        break;
+    }
+    case WM_USER_WAKEUP: {
+        break;
+    }
+    case WM_ACTIVATEAPP:
+        if (wParam) {
+            event_listener->on_app_activated();
+        } else {
+            event_listener->on_app_deactivated();
+        }
+        break;
+    case WM_DISPLAYCHANGE:
+        event_listener->on_monitors_change();
+        break;
+    default:
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    }
+    return 0;
+}
+
+static void create_message_wind()
+{
+    WNDCLASSEX wclass;
+    ATOM class_atom;
+    HWND window;
+
+    const LPCWSTR class_name = L"spicec_platform_wclass";
+
+    wclass.cbSize = sizeof(WNDCLASSEX);
+    wclass.style = 0;
+    wclass.lpfnWndProc = PlatformWinProc;
+    wclass.cbClsExtra = 0;
+    wclass.cbWndExtra = 0;
+    wclass.hInstance = instance;
+    wclass.hIcon = NULL;
+    wclass.hCursor = NULL;
+    wclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
+    wclass.lpszMenuName = NULL;
+    wclass.lpszClassName = class_name;
+    wclass.hIconSm = NULL;
+
+    if ((class_atom = RegisterClassEx(&wclass)) == 0) {
+        THROW("register class failed");
+    }
+
+    if (!(window = CreateWindow(class_name, L"", 0, 0, 0, 0, 0, NULL, NULL, instance, NULL))) {
+        THROW("create message window failed");
+    }
+
+    paltform_win = window;
+}
+
+void Platform::send_quit_request()
+{
+    ASSERT(GetCurrentThread() == main_tread);
+    PostQuitMessage(0);
+}
+
+static std::vector<HANDLE> events;
+static std::vector<EventOwner*> events_owners;
+
+void WinPlatform::add_event(EventOwner& event_owner)
+{
+    ASSERT(main_tread == GetCurrentThread());
+    int size = events.size();
+    if (size == MAXIMUM_WAIT_OBJECTS - 1) {
+        THROW("reached maximum allowed events to wait for");
+    }
+    events.resize(size + 1);
+    events_owners.resize(size + 1);
+    events[size] = event_owner.get_event_handle();
+    events_owners[size] = &event_owner;
+}
+
+void WinPlatform::remove_event(EventOwner& event_owner)
+{
+    ASSERT(main_tread == GetCurrentThread());
+    int size = events.size();
+    for (int i = 0; i < size; i++) {
+        if (events_owners[i] == &event_owner) {
+            for (i++; i < size; i++) {
+                events[i - 1] = events[i];
+                events_owners[i - 1] = events_owners[i];
+            }
+            events.resize(size - 1);
+            events_owners.resize(size - 1);
+            return;
+        }
+    }
+    THROW("event owner not found");
+}
+
+void Platform::wait_events()
+{
+    if (!events.size()) {
+        if (!WaitMessage()) {
+            THROW("wait failed %d", GetLastError());
+        }
+        return;
+    }
+
+    DWORD r = MsgWaitForMultipleObjectsEx(events.size(), &events[0], INFINITE, QS_ALLINPUT, 0);
+    if (r == WAIT_OBJECT_0 + events.size()) {
+        return;
+    }
+    if (r >= WAIT_OBJECT_0 && r <= WAIT_OBJECT_0 + events.size() - 1) {
+        events_owners[r - WAIT_OBJECT_0]->on_event();
+    } else if (r == WAIT_FAILED) {
+        THROW("wait multiple failed %d", GetLastError());
+    } else {
+        THROW("unexpected wait return %u", r);
+    }
+}
+
+NamedPipe::ListenerRef NamedPipe::create(const char *name, ListenerInterface& listener_interface)
+{
+    return (ListenerRef)(new WinListener(name, listener_interface));
+}
+
+void NamedPipe::destroy(ListenerRef listener_ref)
+{
+    delete (WinListener *)listener_ref;
+}
+
+void NamedPipe::destroy_connection(ConnectionRef conn_ref)
+{
+    delete (WinConnection *)conn_ref;
+}
+
+int32_t NamedPipe::read(ConnectionRef conn_ref, uint8_t *buf, int32_t size)
+{
+    return ((WinConnection *)conn_ref)->read(buf, size);
+}
+
+int32_t NamedPipe::write(ConnectionRef conn_ref, const uint8_t *buf, int32_t size)
+{
+    return ((WinConnection *)conn_ref)->write(buf, size);
+}
+
+void Platform::wakeup()
+{
+    if (!PostMessage(paltform_win, WM_USER_WAKEUP, 0, 0)) {
+        THROW("post failed %d", GetLastError());
+    }
+}
+
+bool Platform::process_events()
+{
+    MSG msg;
+    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+        if (msg.message == WM_QUIT) {
+            return true;
+        }
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+    return false;
+}
+
+void Platform::msleep(unsigned int msec)
+{
+    Sleep(msec);
+}
+
+void Platform::yield()
+{
+    Sleep(0);
+}
+
+void Platform::set_thread_priority(void* thread, Platform::ThreadPriority in_priority)
+{
+    ASSERT(thread == NULL);
+    int priority;
+
+    switch (in_priority) {
+    case PRIORITY_TIME_CRITICAL:
+        priority = THREAD_PRIORITY_TIME_CRITICAL;
+        break;
+    case PRIORITY_HIGH:
+        priority = THREAD_PRIORITY_HIGHEST;
+        break;
+    case PRIORITY_ABOVE_NORMAL:
+        priority = THREAD_PRIORITY_ABOVE_NORMAL;
+        break;
+    case PRIORITY_NORMAL:
+        priority = THREAD_PRIORITY_NORMAL;
+        break;
+    case PRIORITY_BELOW_NORMAL:
+        priority = THREAD_PRIORITY_BELOW_NORMAL;
+        break;
+    case PRIORITY_LOW:
+        priority = THREAD_PRIORITY_LOWEST;
+        break;
+    case PRIORITY_IDLE:
+        priority = THREAD_PRIORITY_IDLE;
+        break;
+    default:
+        THROW("invalid priority %d", in_priority);
+    }
+    SetThreadPriority(GetCurrentThread(), priority);
+}
+
+void Platform::set_event_listener(EventListener* listener)
+{
+    event_listener = listener ? listener : &default_event_listener;
+}
+
+TimerID Platform::create_interval_timer(timer_proc_t proc, void* opaque)
+{
+    Timer* timer = alloc_timer();
+    if (!timer) {
+        return INVALID_TIMER;
+    }
+    timer->proc = proc;
+    timer->opaque = opaque;
+    return timer->id;
+}
+
+bool Platform::activate_interval_timer(TimerID timer, unsigned int millisec)
+{
+    if (timer >= NUM_TIMERS) {
+        return false;
+    }
+
+    if (!SetTimer(paltform_win, timer + 1, millisec, NULL)) {
+        return false;
+    }
+    return true;
+}
+
+bool Platform::deactivate_interval_timer(TimerID timer)
+{
+    if (timer >= NUM_TIMERS) {
+        return false;
+    }
+    KillTimer(paltform_win, timer + 1);
+    return true;
+}
+
+void Platform::destroy_interval_timer(TimerID timer)
+{
+    if (timer == INVALID_TIMER) {
+        return;
+    }
+    ASSERT(timer < NUM_TIMERS);
+    KillTimer(paltform_win, timer + 1);
+    free_timer(&timers[timer]);
+}
+
+uint64_t Platform::get_monolithic_time()
+{
+    return uint64_t(GetTickCount()) * 1000 * 1000;
+}
+
+void Platform::get_temp_dir(std::string& path)
+{
+    DWORD len = GetTempPathA(0, NULL);
+    if (len <= 0) {
+        throw Exception("get temp patch failed");
+    }
+    char* tmp_path = new char[len + 1];
+    GetTempPathA(len, tmp_path);
+    path = tmp_path;
+    delete[] tmp_path;
+}
+
+class WinMonitor: public Monitor {
+public:
+    WinMonitor(int id, const wchar_t* name, const wchar_t* string);
+
+    virtual void set_mode(int width, int height);
+    virtual void restore();
+    virtual int get_depth() { return _depth;}
+    virtual Point get_position();
+    virtual Point get_size() const { Point size = {_width, _height}; return size;}
+    virtual bool is_out_of_sync() { return _out_of_sync;}
+    virtual int get_screen_id() { return 0;}
+
+protected:
+    virtual ~WinMonitor();
+
+private:
+    void update_position();
+    bool change_display_settings(int width, int height, int depth);
+    bool best_display_setting(uint32_t width, uint32_t height, uint32_t depth);
+
+private:
+    std::wstring _dev_name;
+    std::wstring _dev_string;
+    bool _active;
+    Point _position;
+    int _width;
+    int _height;
+    int _depth;
+    bool _out_of_sync;
+};
+
+WinMonitor::WinMonitor(int id, const wchar_t* name, const wchar_t* string)
+    : Monitor(id)
+    , _dev_name (name)
+    , _dev_string (string)
+    , _active (false)
+    , _out_of_sync (false)
+{
+    update_position();
+}
+
+WinMonitor::~WinMonitor()
+{
+    restore();
+}
+
+void WinMonitor::update_position()
+{
+    DEVMODE mode;
+    mode.dmSize = sizeof(DEVMODE);
+    mode.dmDriverExtra = 0;
+    EnumDisplaySettings(_dev_name.c_str(), ENUM_CURRENT_SETTINGS, &mode);
+    _position.x = mode.dmPosition.x;
+    _position.y = mode.dmPosition.y;
+    _width = mode.dmPelsWidth;
+    _height = mode.dmPelsHeight;
+    _depth = mode.dmBitsPerPel;
+}
+
+Point WinMonitor::get_position()
+{
+    update_position();
+    return _position;
+}
+
+bool WinMonitor::change_display_settings(int width, int height, int depth)
+{
+    DEVMODE mode;
+    mode.dmSize = sizeof(DEVMODE);
+    mode.dmDriverExtra = 0;
+    mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
+    mode.dmPelsWidth = width;
+    mode.dmPelsHeight = height;
+    mode.dmBitsPerPel = depth;
+
+    return ChangeDisplaySettingsEx(_dev_name.c_str(), &mode, NULL, CDS_FULLSCREEN, NULL)
+                                                                        == DISP_CHANGE_SUCCESSFUL;
+}
+
+bool WinMonitor::best_display_setting(uint32_t width, uint32_t height, uint32_t depth)
+{
+    DEVMODE mode;
+    DWORD mode_id = 0;
+    uint32_t mod_waste = ~0;
+    DWORD mod_width;
+    DWORD mod_height;
+    DWORD mod_depth;
+    DWORD mod_frequency;
+
+    mode.dmSize = sizeof(DEVMODE);
+    mode.dmDriverExtra = 0;
+    while (EnumDisplaySettings(_dev_name.c_str(), mode_id++, &mode)) {
+        // Workaround for
+        // Lenovo T61p, Nvidia Quadro FX 570M and
+        // Lenovo T61, Nvidia Quadro NVS 140M
+        //
+        // with dual monitors configuration
+        //
+        // we get strange values from EnumDisplaySettings 640x480x4 frequency 1
+        // and calling ChangeDisplaySettingsEx with that configuration result with
+        // machine that is stucked for a long period of time
+        if (mode.dmDisplayFrequency == 1) {
+            continue;
+        }
+
+        if (mode.dmPelsWidth >= width && mode.dmPelsHeight >= height) {
+            bool replace = false;
+            uint32_t curr_waste = mode.dmPelsWidth * mode.dmPelsHeight - width * height;
+            if (curr_waste < mod_waste) {
+                replace = true;
+            } else if (curr_waste == mod_waste) {
+                if (mod_depth == mode.dmBitsPerPel) {
+                    replace = mode.dmDisplayFrequency > mod_frequency;
+                } else if (mod_depth != depth && mode.dmBitsPerPel > mod_depth) {
+                    replace = true;
+                }
+            }
+            if (replace) {
+                mod_waste = curr_waste;
+                mod_width = mode.dmPelsWidth;
+                mod_height = mode.dmPelsHeight;
+                mod_depth = mode.dmBitsPerPel;
+                mod_frequency = mode.dmDisplayFrequency;
+            }
+        }
+    }
+    if (mod_waste == ~0) {
+        return false;
+    }
+    mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
+    mode.dmPelsWidth = mod_width;
+    mode.dmPelsHeight = mod_height;
+    mode.dmBitsPerPel = mod_depth;
+    mode.dmDisplayFrequency = mod_frequency;
+
+    return ChangeDisplaySettingsEx(_dev_name.c_str(), &mode, NULL, CDS_FULLSCREEN, NULL)
+                                                                        == DISP_CHANGE_SUCCESSFUL;
+}
+
+void WinMonitor::set_mode(int width, int height)
+{
+    update_position();
+    if (width == _width && height == _height) {
+        _out_of_sync = false;
+        return;
+    }
+    self_monitors_change++;
+    if (!change_display_settings(width, height, 32) && !best_display_setting(width, height, 32)) {
+        _out_of_sync = true;
+    } else {
+        _out_of_sync = false;
+    }
+    self_monitors_change--;
+    _active = true;
+    update_position();
+}
+
+void WinMonitor::restore()
+{
+    if (_active) {
+        _active = false;
+        self_monitors_change++;
+        ChangeDisplaySettingsEx(_dev_name.c_str(), NULL, NULL, 0, NULL);
+        self_monitors_change--;
+    }
+}
+
+static MonitorsList monitors;
+
+const MonitorsList& Platform::init_monitors()
+{
+    ASSERT(monitors.empty());
+
+    int id = 0;
+    DISPLAY_DEVICE device_info;
+    DWORD device_id = 0;
+    device_info.cb = sizeof(device_info);
+    while (EnumDisplayDevices(NULL, device_id, &device_info, 0)) {
+        if ((device_info.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) &&
+                                      !(device_info.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER)) {
+            monitors.push_back(new WinMonitor(id++, device_info.DeviceName,
+                                              device_info.DeviceString));
+        }
+        device_id++;
+    }
+    return monitors;
+}
+
+void Platform::destroy_monitors()
+{
+    while (!monitors.empty()) {
+        Monitor* monitor = monitors.front();
+        monitors.pop_front();
+        delete monitor;
+    }
+}
+
+bool Platform::is_monitors_pos_valid()
+{
+    return true;
+}
+
+void Platform::init()
+{
+    main_tread = GetCurrentThread();
+    create_message_wind();
+    init_timers();
+}
+
+WaveRecordAbstract* Platform::create_recorder(RecordClinet& client,
+                                              uint32_t sampels_per_sec,
+                                              uint32_t bits_per_sample,
+                                              uint32_t channels)
+{
+    return new WaveRecorder(client, sampels_per_sec, bits_per_sample, channels);
+}
+
+WavePlaybackAbstract* Platform::create_player(uint32_t sampels_per_sec,
+                                              uint32_t bits_per_sample,
+                                              uint32_t channels)
+{
+    return new WavePlayer(sampels_per_sec, bits_per_sample, channels);
+}
+
+static void toggle_modifier(int key)
+{
+    INPUT inputs[2];
+    memset(inputs, 0, sizeof(inputs));
+    inputs[0].type = inputs[1].type = INPUT_KEYBOARD;
+    inputs[0].ki.wVk = inputs[1].ki.wVk = key;
+    inputs[1].ki.dwFlags = KEYEVENTF_KEYUP;
+    SendInput(2, inputs, sizeof(INPUT));
+}
+
+uint32_t Platform::get_keyboard_modifiers()
+{
+    uint32_t modifiers = 0;
+    if ((GetKeyState(VK_SCROLL) & 1)) {
+        modifiers |= SCROLL_LOCK_MODIFIER;
+    }
+    if ((GetKeyState(VK_NUMLOCK) & 1)) {
+        modifiers |= NUM_LOCK_MODIFIER;
+    }
+    if ((GetKeyState(VK_CAPITAL) & 1)) {
+        modifiers |= CAPS_LOCK_MODIFIER;
+    }
+    return modifiers;
+}
+
+void Platform::set_keyboard_modifiers(uint32_t modifiers)
+{
+    if (((modifiers >> SCROLL_LOCK_MODIFIER_SHIFT) & 1) != (GetKeyState(VK_SCROLL) & 1)) {
+        toggle_modifier(VK_SCROLL);
+    }
+
+    if (((modifiers >> Platform::NUM_LOCK_MODIFIER_SHIFT) & 1) != (GetKeyState(VK_NUMLOCK) & 1)) {
+        toggle_modifier(VK_NUMLOCK);
+    }
+
+    if (((modifiers >> CAPS_LOCK_MODIFIER_SHIFT) & 1) != (GetKeyState(VK_CAPITAL) & 1)) {
+        toggle_modifier(VK_CAPITAL);
+    }
+}
+
+class WinBaseLocalCursor: public LocalCursor {
+public:
+    WinBaseLocalCursor() : _handle (0) {}
+    void set(Window window) { SetCursor(_handle);}
+
+protected:
+    HCURSOR _handle;
+};
+
+class WinLocalCursor: public WinBaseLocalCursor {
+public:
+    WinLocalCursor(CursorData* cursor_data);
+    ~WinLocalCursor();
+
+private:
+    bool _shared;
+};
+
+WinLocalCursor::WinLocalCursor(CursorData* cursor_data)
+    : _shared (false)
+{
+    const CursorHeader& header = cursor_data->header();
+    const uint8_t* data = cursor_data->data();
+    int cur_size;
+    int bits = get_size_bits(header, cur_size);
+    if (!bits) {
+        THROW("invalid curosr type");
+    }
+    if (header.type == CURSOR_TYPE_MONO) {
+        _handle = CreateCursor(NULL, header.hot_spot_x, header.hot_spot_y,
+                               header.width, header.height, data, data + cur_size);
+        return;
+    }
+    ICONINFO icon;
+    icon.fIcon = FALSE;
+    icon.xHotspot = header.hot_spot_x;
+    icon.yHotspot = header.hot_spot_y;
+    icon.hbmColor = icon.hbmMask = NULL;
+    HDC hdc = GetDC(NULL);
+    
+    switch (header.type) {
+    case CURSOR_TYPE_ALPHA:
+    case CURSOR_TYPE_COLOR32:
+    case CURSOR_TYPE_COLOR16: {
+        BITMAPV5HEADER bmp_hdr;
+        ZeroMemory(&bmp_hdr, sizeof(bmp_hdr));
+        bmp_hdr.bV5Size = sizeof(bmp_hdr);
+        bmp_hdr.bV5Width = header.width;
+        bmp_hdr.bV5Height = -header.height;
+        bmp_hdr.bV5Planes = 1;
+        bmp_hdr.bV5BitCount = bits;
+        bmp_hdr.bV5Compression = BI_BITFIELDS;
+        if (bits == 32) {
+            bmp_hdr.bV5RedMask   = 0x00FF0000;
+            bmp_hdr.bV5GreenMask = 0x0000FF00;
+            bmp_hdr.bV5BlueMask  = 0x000000FF;
+        } else if (bits == 16) {
+            bmp_hdr.bV5RedMask   = 0x00007C00;
+            bmp_hdr.bV5GreenMask = 0x000003E0;
+            bmp_hdr.bV5BlueMask  = 0x0000001F;
+        }
+        if (header.type == CURSOR_TYPE_ALPHA) {
+            bmp_hdr.bV5AlphaMask = 0xFF000000;
+        }
+        void* bmp_pixels = NULL;
+        icon.hbmColor = CreateDIBSection(hdc, (BITMAPINFO *)&bmp_hdr, DIB_RGB_COLORS, &bmp_pixels,
+                                         NULL, 0);
+        memcpy(bmp_pixels, data, cur_size);
+        icon.hbmMask = CreateBitmap(header.width, header.height, 1, 1,
+                                    (header.type == CURSOR_TYPE_ALPHA) ? NULL :
+                                                                   (CONST VOID *)(data + cur_size));
+        break;
+    }
+    case CURSOR_TYPE_COLOR4: {
+        BITMAPINFO* bmp_info;
+        bmp_info = (BITMAPINFO *)new uint8_t[sizeof(BITMAPINFO) + (sizeof(RGBQUAD) << bits)];
+        ZeroMemory(bmp_info, sizeof(BITMAPINFO));
+        bmp_info->bmiHeader.biSize = sizeof(bmp_info->bmiHeader);
+        bmp_info->bmiHeader.biWidth = header.width;
+        bmp_info->bmiHeader.biHeight = -header.height;
+        bmp_info->bmiHeader.biPlanes = 1;
+        bmp_info->bmiHeader.biBitCount = bits;
+        bmp_info->bmiHeader.biCompression =  BI_RGB;
+        memcpy(bmp_info->bmiColors, data + cur_size, sizeof(RGBQUAD) << bits);
+        icon.hbmColor = CreateDIBitmap(hdc, &bmp_info->bmiHeader, CBM_INIT, data,
+                                       bmp_info, DIB_RGB_COLORS);
+        icon.hbmMask = CreateBitmap(header.width, header.height, 1, 1,
+                                    (CONST VOID *)(data + cur_size + (sizeof(uint32_t) << bits)));
+        delete[] (uint8_t *)bmp_info;
+        break;
+    }
+    case CURSOR_TYPE_COLOR24:
+    case CURSOR_TYPE_COLOR8:
+    default:
+        LOG_WARN("unsupported cursor type %d", header.type);
+        _handle = LoadCursor(NULL, IDC_ARROW);
+        _shared = true;
+        ReleaseDC(NULL, hdc);
+        return;
+    }
+
+    ReleaseDC(NULL, hdc);
+
+    if (icon.hbmColor && icon.hbmMask) {
+        _handle = CreateIconIndirect(&icon);
+    }
+    if (icon.hbmMask) {
+        DeleteObject(icon.hbmMask);
+    }
+    if (icon.hbmColor) {
+        DeleteObject(icon.hbmColor);
+    }
+}
+
+WinLocalCursor::~WinLocalCursor()
+{
+    if (_handle && !_shared) {
+        DestroyCursor(_handle);
+    }
+}
+
+LocalCursor* Platform::create_local_cursor(CursorData* cursor_data)
+{
+    return new WinLocalCursor(cursor_data);
+}
+
+class WinInactiveCursor: public WinBaseLocalCursor {
+public:
+    WinInactiveCursor() { _handle = LoadCursor(NULL, IDC_NO);}
+};
+
+LocalCursor* Platform::create_inactive_cursor()
+{
+    return new WinInactiveCursor();
+}
+
+class WinDefaultCursor: public WinBaseLocalCursor {
+public:
+    WinDefaultCursor() { _handle = LoadCursor(NULL, IDC_ARROW);}
+};
+
+LocalCursor* Platform::create_default_cursor()
+{
+    return new WinDefaultCursor();
+}
+
+void Platform::set_display_mode_listner(DisplayModeListner* listener)
+{
+}
+
+Icon* Platform::load_icon(int id)
+{
+    HICON icon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(id));
+    if (!icon) {
+        return NULL;
+    }
+    return new WinIcon(icon);
+}
+
diff --git a/client/windows/platform_utils.cpp b/client/windows/platform_utils.cpp
new file mode 100644
index 00000000..6b9049a0
--- /dev/null
+++ b/client/windows/platform_utils.cpp
@@ -0,0 +1,151 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include <map>
+#include "platform_utils.h"
+#include "utils.h"
+#include "threads.h"
+
+void string_vprintf(std::string& str, const char* format, va_list ap)
+{
+    int buf_size = 256;
+    for (;;) {
+        AutoArray<char> buf(new char[buf_size]);
+        int r = vsnprintf_s(buf.get(), buf_size, buf_size - 1, format, ap);
+        if (r != -1) {
+            str = buf.get();
+            return;
+        }
+        buf_size *= 2;
+    }
+}
+
+void wstring_vprintf(std::wstring& str, const wchar_t* format, va_list ap)
+{
+    int buf_size = 256;
+    for (;;) {
+        AutoArray<wchar_t> buf(new wchar_t[buf_size]);
+        int r = vswprintf(buf.get(), buf_size, format, ap);
+        if (r != -1) {
+            str = buf.get();
+            return;
+        }
+        buf_size *= 2;
+    }
+}
+
+HDC create_compatible_dc()
+{
+    HDC dc = CreateCompatibleDC(NULL);
+    if (!dc) {
+        THROW("create compatible DC failed");
+    }
+    return dc;
+}
+
+HBITMAP get_bitmap_res(int id)
+{
+    HBITMAP bitmap = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(id));
+    if (!bitmap) {
+        THROW("get bitmpa #%d failed", id);
+    }
+    return bitmap;
+}
+
+HBITMAP get_alpha_bitmap_res(int id)
+{
+    AutoGDIObject bitmap(LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(id), IMAGE_BITMAP, 0, 0,
+                                   LR_DEFAULTCOLOR | LR_CREATEDIBSECTION | LR_SHARED));
+    if (!bitmap.valid()) {
+        THROW("get bitmpa #%d failed", id);
+    }
+
+    BITMAP src_info;
+    GetObject(bitmap.get(), sizeof(src_info), &src_info);
+    if (src_info.bmBitsPixel != 32 || src_info.bmPlanes != 1) {
+        THROW("invalid format #%d ", id);
+    }
+
+    LONG src_size = src_info.bmHeight * src_info.bmWidthBytes;
+    AutoArray<uint8_t> src_pixels(new uint8_t[src_size]);
+    LONG ncopy = GetBitmapBits((HBITMAP)bitmap.get(), src_size, src_pixels.get());
+    if (ncopy != src_size) {
+        THROW("get vitmap bits failed, %u", GetLastError());
+    }
+
+    AutoDC auto_dc(create_compatible_dc());
+    BITMAPINFO dest_info;
+    uint8_t *dest;
+    dest_info.bmiHeader.biSize = sizeof(dest_info.bmiHeader);
+    dest_info.bmiHeader.biWidth = src_info.bmWidth;
+    dest_info.bmiHeader.biHeight = -src_info.bmHeight;
+    dest_info.bmiHeader.biPlanes = 1;
+    dest_info.bmiHeader.biBitCount = 32;
+    dest_info.bmiHeader.biCompression = BI_RGB;
+    dest_info.bmiHeader.biSizeImage = 0;
+    dest_info.bmiHeader.biXPelsPerMeter = dest_info.bmiHeader.biYPelsPerMeter = 0;
+    dest_info.bmiHeader.biClrUsed = 0;
+    dest_info.bmiHeader.biClrImportant = 0;
+
+    HBITMAP ret = CreateDIBSection(auto_dc.get(), &dest_info, 0, (VOID **)&dest, NULL, 0);
+    if (!ret) {
+        THROW("create bitmap failed, %u", GetLastError());
+    }
+
+    uint8_t* src_line = src_pixels.get();
+    for (int i = 0; i < src_info.bmHeight; i++, src_line += src_info.bmWidthBytes) {
+        uint8_t* src = src_line;
+        for (int j = 0; j < src_info.bmWidth; j++) {
+            dest[3] = src[3];
+            double alpha = (double)dest[3] / 0xff;
+            dest[2] = (uint8_t)(alpha * src[2]);
+            dest[1] = (uint8_t)(alpha * src[1]);
+            dest[0] = (uint8_t)(alpha * src[0]);
+            src += 4;
+            dest += 4;
+        }
+    }
+    return ret;
+}
+
+static std::map<int, const char*> errors_map;
+static Mutex errors_map_mutex;
+
+const char* sys_err_to_str(int error)
+{
+    Lock lock(errors_map_mutex);
+    if (errors_map.find(error) == errors_map.end()) {
+        LPSTR msg;
+        if (!FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+                            FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error,
+                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                            (LPSTR)&msg, 0, NULL)) {
+            const int BUF_SIZE = 20;
+            msg = new char[BUF_SIZE];
+            _snprintf(msg, BUF_SIZE, "errno %d", error);
+        } else {
+            char *new_line;
+            if ((new_line = strrchr(msg, '\r'))) {
+                *new_line = 0;
+            }
+        }
+        errors_map[error] = msg;
+    }
+    return errors_map[error];
+}
+
diff --git a/client/windows/platform_utils.h b/client/windows/platform_utils.h
new file mode 100644
index 00000000..95b04fcb
--- /dev/null
+++ b/client/windows/platform_utils.h
@@ -0,0 +1,84 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PLATFORM_UTILS
+#define _H_PLATFORM_UTILS
+
+#define mb() __asm {lock add [esp], 0}
+
+template<class T, class FreeRes = FreeObject<T>, T invalid = NULL >
+class AutoRes {
+public:
+    AutoRes() : res (invalid) {}
+    AutoRes(T inRes) : res (inRes) {}
+    ~AutoRes() { set(invalid); }
+
+    void set(T inRes) {if (res != invalid) free_res(res); res = inRes; }
+    T get() {return res;}
+    T release() {T tmp = res; res = invalid; return tmp; }
+    bool valid() { return res != invalid; }
+
+private:
+    AutoRes(const AutoRes&);
+    AutoRes& operator = (const AutoRes&);
+
+private:
+    T res;
+    FreeRes free_res;
+};
+
+class Delete_DC {
+public:
+    void operator () (HDC dc) { DeleteDC(dc);}
+};
+
+typedef AutoRes<HDC, Delete_DC> AutoDC;
+
+class Delete_Object {
+public:
+    void operator () (HGDIOBJ obj) { DeleteObject(obj);}
+};
+typedef AutoRes<HGDIOBJ, Delete_Object> AutoGDIObject;
+
+class DeleteOGLContext {
+public:
+    void operator () (HGLRC ctx) { wglDeleteContext(ctx);}
+};
+
+typedef AutoRes<HGLRC, DeleteOGLContext> AutoOGLCtx;
+
+HDC create_compatible_dc();
+HBITMAP get_bitmap_res(int id);
+HBITMAP get_alpha_bitmap_res(int id);
+
+class WindowDC {
+public:
+    WindowDC(HWND window) : _window (window), _dc (GetDC(window)) {}
+    ~WindowDC() { ReleaseDC(_window, _dc);}
+    HDC operator * () { return _dc;}
+
+private:
+    HWND _window;
+    HDC _dc;
+};
+
+typedef AutoRes<HDC, Delete_DC> AutoReleaseDC;
+
+const char* sys_err_to_str(int error);
+
+#endif
+
diff --git a/client/windows/playback.cpp b/client/windows/playback.cpp
new file mode 100644
index 00000000..2e15ad93
--- /dev/null
+++ b/client/windows/playback.cpp
@@ -0,0 +1,177 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "playback.h"
+#include "utils.h"
+#include "debug.h"
+
+
+#define RING_SIZE_MS 160
+#define START_MARK_MS 80
+#define LOW_MARK_MS 40
+
+
+WavePlayer::WavePlayer(uint32_t sampels_per_sec, uint32_t bits_per_sample, uint32_t channels)
+    : _wave_out (NULL)
+    , _sampels_per_ms (sampels_per_sec / 1000)
+    , _ring (NULL)
+    , _head (0)
+    , _in_use (0)
+    , _paused (true)
+{
+    WAVEFORMATEX info;
+    uint32_t sample_bytes;
+
+    info.wFormatTag = WAVE_FORMAT_PCM;
+    info.nChannels = channels;
+    info.nSamplesPerSec = sampels_per_sec;
+    sample_bytes = info.nBlockAlign = channels * bits_per_sample / 8;
+    info.nAvgBytesPerSec = sampels_per_sec * info.nBlockAlign;
+    info.wBitsPerSample = bits_per_sample;
+
+    if (waveOutOpen(&_wave_out, WAVE_MAPPER, &info, NULL, NULL, CALLBACK_NULL)
+                                                            != MMSYSERR_NOERROR) {
+        throw Exception("can not open playback device");
+    }
+
+    int frame_size = WavePlaybackAbstract::FRAME_SIZE;
+    _ring_size = (sampels_per_sec * RING_SIZE_MS / 1000) / frame_size;
+    int low_mark = (sampels_per_sec * LOW_MARK_MS / 1000) / frame_size;
+    _start_mark = (sampels_per_sec * START_MARK_MS / 1000) / frame_size;
+    _frame_bytes = frame_size * channels * bits_per_sample / 8;
+    _ring_item_size = sizeof(WAVEHDR) + _frame_bytes + sample_bytes;
+
+    try {
+        _ring = new uint8_t[_ring_size * _ring_item_size];
+        init_ring(sample_bytes);
+    } catch (...) {
+        delete[] _ring;
+        waveOutClose(_wave_out);
+        throw;
+    }
+    waveOutPause(_wave_out);
+}
+
+WavePlayer::~WavePlayer()
+{
+    waveOutReset(_wave_out);
+    reclaim();
+    waveOutClose(_wave_out);
+    delete[] _ring;
+}
+
+void WavePlayer::init_ring(uint32_t sample_bytes)
+{
+    uint8_t* ptr = _ring;
+    uint8_t* end = ptr + _ring_size * _ring_item_size;
+    for (; ptr != end; ptr += _ring_item_size) {
+        WAVEHDR* buf = (WAVEHDR*)ptr;
+        memset(ptr, 0, _ring_item_size);
+        buf->dwBufferLength = _frame_bytes;
+        ULONG_PTR ptr = (ULONG_PTR)(buf + 1);
+        ptr = (ptr + sample_bytes - 1) / sample_bytes * sample_bytes;
+        buf->lpData = (LPSTR)ptr;
+    }
+}
+
+inline WAVEHDR* WavePlayer::wave_hader(uint32_t position)
+{
+    ASSERT(position < _ring_size);
+    return (WAVEHDR*)(_ring + position * _ring_item_size);
+}
+
+inline void WavePlayer::move_head()
+{
+    _head = (_head + 1) % _ring_size;
+    _in_use--;
+}
+
+void WavePlayer::reclaim()
+{
+    while (_in_use) {
+        WAVEHDR* front_buf = wave_hader(_head);
+        if (!(front_buf->dwFlags & WHDR_DONE)) {
+            break;
+        }
+        MMRESULT err = waveOutUnprepareHeader(_wave_out, front_buf, sizeof(WAVEHDR));
+        if (err != MMSYSERR_NOERROR) {
+            LOG_WARN("waveOutUnprepareHeader failed %u", err);
+        }
+        front_buf->dwFlags &= ~WHDR_DONE;
+        move_head();
+    }
+}
+
+WAVEHDR* WavePlayer::get_buff()
+{
+    reclaim();
+    if (_in_use == _ring_size) {
+        return NULL;
+    }
+
+    WAVEHDR* buff = wave_hader((_head + _in_use) % _ring_size);
+    ++_in_use;
+    return buff;
+}
+
+bool WavePlayer::write(uint8_t* frame)
+{
+    WAVEHDR* buff = get_buff();
+    if (buff) {
+        memcpy(buff->lpData, frame, _frame_bytes);
+        MMRESULT err;
+        err = waveOutPrepareHeader(_wave_out, buff, sizeof(WAVEHDR));
+
+        if (err != MMSYSERR_NOERROR) {
+            THROW("waveOutPrepareHeader filed %d", err);
+        }
+        err = waveOutWrite(_wave_out, buff, sizeof(WAVEHDR));
+        if (err != MMSYSERR_NOERROR) {
+            THROW("waveOutWrite filed %d", err);
+        }
+    }
+    if (_paused && _in_use == _start_mark) {
+        _paused = false;
+        waveOutRestart(_wave_out);
+    }
+    return true;
+}
+
+void WavePlayer::drain()
+{
+}
+
+void WavePlayer::stop()
+{
+    drain();
+    waveOutReset(_wave_out);
+    waveOutPause(_wave_out);
+    _paused = true;
+    reclaim();
+}
+
+bool WavePlayer::abort()
+{
+    return true;
+}
+
+uint32_t WavePlayer::get_delay_ms()
+{
+    return _in_use * WavePlaybackAbstract::FRAME_SIZE / _sampels_per_ms;
+}
+
diff --git a/client/windows/playback.h b/client/windows/playback.h
new file mode 100644
index 00000000..9a50cdba
--- /dev/null
+++ b/client/windows/playback.h
@@ -0,0 +1,55 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_WINDOWS_AUDIO_PLAYBACK
+#define _H_WINDOWS_AUDIO_PLAYBACK
+
+#include "audio_devices.h"
+
+class WavePlayer: public WavePlaybackAbstract {
+public:
+    WavePlayer(uint32_t sampels_per_sec, uint32_t bits_per_sample, uint32_t channels);
+    virtual ~WavePlayer();
+
+    virtual bool write(uint8_t* frame);
+    virtual bool abort();
+    virtual void stop();
+    virtual uint32_t get_delay_ms();
+
+private:
+    WAVEHDR* wave_hader(uint32_t position);
+    void move_head();
+    WAVEHDR* get_buff();
+    void reclaim();
+    void drain();
+    void init_ring(uint32_t sample_bytes);
+
+private:
+    HWAVEOUT _wave_out;
+    uint32_t _sampels_per_ms;
+    uint32_t _frame_bytes;
+    uint32_t _start_mark;
+    uint32_t _ring_item_size;
+    uint8_t* _ring;
+    uint32_t _ring_size;
+    uint32_t _head;
+    uint32_t _in_use;
+    bool _paused;
+};
+
+#endif
+
diff --git a/client/windows/record.cpp b/client/windows/record.cpp
new file mode 100644
index 00000000..52fc478e
--- /dev/null
+++ b/client/windows/record.cpp
@@ -0,0 +1,193 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "record.h"
+#include "utils.h"
+#include "debug.h"
+
+#define RING_SIZE_MS 500
+
+static void CALLBACK in_proc(HWAVEIN handle, UINT msg, DWORD user_data, DWORD param1,
+                             DWORD param2)
+{
+    WaveRecorder* recorder = (WaveRecorder*)user_data;
+    recorder->trigger();
+}
+
+WaveRecorder::WaveRecorder(Platform::RecordClinet& client, uint32_t sampels_per_sec,
+                           uint32_t bits_per_sample, uint32_t channels)
+    : _client (client)
+    , _ring (NULL)
+    , _frame (NULL)
+    , _head (0)
+    , _in_use (0)
+{
+    WAVEFORMATEX info;
+    uint32_t frame_align;
+
+    info.wFormatTag = WAVE_FORMAT_PCM;
+    info.nChannels = channels;
+    info.nSamplesPerSec = sampels_per_sec;
+    info.nBlockAlign = frame_align = channels * bits_per_sample / 8;
+    info.nAvgBytesPerSec = sampels_per_sec * info.nBlockAlign;
+    info.wBitsPerSample = bits_per_sample;
+
+
+    if (waveInOpen(&_wave_in, WAVE_MAPPER, &info, (DWORD_PTR)in_proc, (DWORD_PTR)this,
+                   CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
+        throw Exception("cannot open playback device");
+    }
+
+    try {
+        const int frame_size = WavePlaybackAbstract::FRAME_SIZE;
+        uint32_t frame_bytes = frame_size * channels * bits_per_sample / 8;
+
+        _frame = new uint8_t[frame_bytes];
+        _frame_pos = _frame;
+        _frame_end = _frame + frame_bytes;
+        init_ring(sampels_per_sec, frame_bytes, frame_align);
+        _client.add_evnet_sorce(*this);
+    } catch (...) {
+        delete[] _ring;
+        delete[] _frame;
+        waveInClose(_wave_in);
+        throw;
+    }
+}
+
+WaveRecorder::~WaveRecorder()
+{
+    waveInReset(_wave_in);
+    reclaim();
+    _client.remove_evnet_sorce(*this);
+    waveInClose(_wave_in);
+    delete[] _ring;
+    delete[] _frame;
+}
+
+void WaveRecorder::init_ring(uint32_t sampels_per_sec, uint32_t frame_bytes, uint32_t frame_align)
+{
+    const int frame_size = WavePlaybackAbstract::FRAME_SIZE;
+
+    _ring_size = (sampels_per_sec * RING_SIZE_MS / 1000) / frame_size;
+    _ring_item_size = sizeof(WAVEHDR) + frame_bytes + frame_align;
+
+    int ring_bytes = _ring_size * _ring_item_size;
+    _ring = new uint8_t[ring_bytes];
+
+    uint8_t* ptr = _ring;
+    uint8_t* end = ptr + ring_bytes;
+    for (; ptr != end; ptr += _ring_item_size) {
+        WAVEHDR* buf = (WAVEHDR*)ptr;
+        memset(ptr, 0, _ring_item_size);
+        buf->dwBufferLength = frame_bytes;
+        ULONG_PTR ptr = (ULONG_PTR)(buf + 1);
+        ptr = (ptr + frame_align - 1) / frame_align * frame_align;
+        buf->lpData = (LPSTR)(buf + 1);
+    }
+}
+
+void WaveRecorder::start()
+{
+    _frame_pos = _frame;
+    waveInReset(_wave_in);
+    push_frames();
+    waveInStart(_wave_in);
+}
+
+inline WAVEHDR* WaveRecorder::wave_hader(uint32_t position)
+{
+    ASSERT(position < _ring_size);
+    return (WAVEHDR*)(_ring + position * _ring_item_size);
+}
+
+inline void WaveRecorder::move_head()
+{
+    _head = (_head + 1) % _ring_size;
+    _in_use--;
+}
+
+void WaveRecorder::push_frames()
+{
+    while (_in_use != _ring_size) {
+        WAVEHDR* buff = wave_hader((_head + _in_use) % _ring_size);
+        ++_in_use;
+
+        MMRESULT err = waveInPrepareHeader(_wave_in, buff, sizeof(WAVEHDR));
+        if (err != MMSYSERR_NOERROR) {
+            THROW("waveInPrepareHeader filed %d", err);
+        }
+        err = waveInAddBuffer(_wave_in, buff, sizeof(WAVEHDR));
+        if (err != MMSYSERR_NOERROR) {
+            THROW("waveInAddBuffer filed %d", err);
+        }
+    }
+}
+
+void WaveRecorder::on_event()
+{
+    while (_in_use) {
+        WAVEHDR* front_buf = wave_hader(_head);
+        if (!(front_buf->dwFlags & WHDR_DONE)) {
+            break;
+        }
+        waveInUnprepareHeader(_wave_in, front_buf, sizeof(WAVEHDR));
+        front_buf->dwFlags &= ~WHDR_DONE;
+        int n = front_buf->dwBytesRecorded;
+        front_buf->dwBytesRecorded = 0;
+        uint8_t* ptr = (uint8_t*)front_buf->lpData;
+        while (n) {
+            int now = MIN(n, _frame_end - _frame_pos);
+            memcpy(_frame_pos, ptr, now);
+            if ((_frame_pos += n) == _frame_end) {
+                _client.push_frame(_frame);
+                _frame_pos = _frame;
+            }
+            n -= now;
+            ptr += now;
+        }
+        move_head();
+        push_frames();
+    }
+}
+
+void WaveRecorder::reclaim()
+{
+    while (_in_use) {
+        WAVEHDR* front_buf = wave_hader(_head);
+        if (!(front_buf->dwFlags & WHDR_DONE)) {
+            break;
+        }
+        waveInUnprepareHeader(_wave_in, front_buf, sizeof(WAVEHDR));
+        front_buf->dwFlags &= ~WHDR_DONE;
+        front_buf->dwBytesRecorded = 0;
+        move_head();
+    }
+}
+
+void WaveRecorder::stop()
+{
+    waveInReset(_wave_in);
+    reclaim();
+}
+
+bool WaveRecorder::abort()
+{
+    return true;
+}
+
diff --git a/client/windows/record.h b/client/windows/record.h
new file mode 100644
index 00000000..dab69fa0
--- /dev/null
+++ b/client/windows/record.h
@@ -0,0 +1,58 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_WINDOWS_RECORD
+#define _H_WINDOWS_RECORD
+
+#include "audio_devices.h"
+#include "platform.h"
+
+class WaveRecorder: public WaveRecordAbstract, public EventsLoop::Trigger {
+public:
+    WaveRecorder(Platform::RecordClinet& client, uint32_t sampels_per_sec,
+                 uint32_t bits_per_sample, uint32_t channels);
+    virtual ~WaveRecorder();
+
+    virtual void start();
+    virtual void stop();
+    virtual bool abort();
+
+    virtual void on_event();
+
+private:
+    void init_ring(uint32_t sampels_per_sec, uint32_t frame_bytes, uint32_t frame_align);
+    WAVEHDR* wave_hader(uint32_t position);
+    void move_head();
+
+    void reclaim();
+    void push_frames();
+
+private:
+    Platform::RecordClinet& _client;
+    HWAVEIN _wave_in;
+    uint8_t* _ring;
+    uint32_t _ring_item_size;
+    uint32_t _ring_size;
+    uint32_t _head;
+    uint32_t _in_use;
+    uint8_t* _frame;
+    uint8_t* _frame_pos;
+    uint8_t* _frame_end;
+};
+
+#endif
+
diff --git a/client/windows/red_drawable.cpp b/client/windows/red_drawable.cpp
new file mode 100644
index 00000000..13d4a21e
--- /dev/null
+++ b/client/windows/red_drawable.cpp
@@ -0,0 +1,151 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_drawable.h"
+#include "pixels_source_p.h"
+#include "utils.h"
+#include "threads.h"
+
+static const uint64_t lock_timout = 1000 * 1000 * 10; /*10ms*/
+
+void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest)
+{
+    PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+    PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
+
+    for (;;) {
+        Lock lock(*dest_p_data->_mutex);
+        Lock timed_lock(*src_p_data->_mutex, lock_timout);
+        if (!timed_lock.is_locked()) {
+            continue;
+        }
+        BitBlt(dest_p_data->dc, dest.left + _origin.x, dest.top + _origin.y,
+               dest.right - dest.left, dest.bottom - dest.top,
+               src_p_data->dc, src_x + src._origin.x,
+               src_y + src._origin.y, SRCCOPY);
+        return;
+    }
+}
+
+void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest)
+{
+    static BLENDFUNCTION blend_func = { AC_SRC_OVER, 0, 0xff, AC_SRC_ALPHA};
+
+    int width = dest.right - dest.left;
+    int height = dest.bottom - dest.top;
+    PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+    PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
+    for (;;) {
+        Lock lock(*dest_p_data->_mutex);
+        Lock timed_lock(*src_p_data->_mutex, lock_timout);
+        if (!timed_lock.is_locked()) {
+            continue;
+        }
+        AlphaBlend(dest_p_data->dc, dest.left + _origin.x, dest.top + _origin.y, width, height,
+                   src_p_data->dc, src_x + src._origin.x, src_y + src._origin.y, width, height,
+                   blend_func);
+        return;
+    }
+}
+
+void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& dest,
+                                 CombineOP op)
+{
+    DWORD rop;
+    switch (op) {
+    case OP_COPY:
+        rop = SRCCOPY;
+        break;
+    case OP_AND:
+        rop = SRCAND;
+        break;
+    case OP_XOR:
+        rop = SRCINVERT;
+        break;
+    default:
+        THROW("invalid op %d", op);
+    }
+
+    PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+    PixelsSource_p* src_p_data = (PixelsSource_p*)src.get_opaque();
+    for (;;) {
+        Lock lock(*dest_p_data->_mutex);
+        Lock timed_lock(*src_p_data->_mutex, lock_timout);
+        if (!timed_lock.is_locked()) {
+            continue;
+        }
+        BitBlt(dest_p_data->dc, dest.left + _origin.x, dest.top + _origin.y,
+               dest.right - dest.left, dest.bottom - dest.top,
+               src_p_data->dc, src_x + src._origin.x,
+               src_y + src._origin.y, rop);
+        return;
+    }
+}
+
+void RedDrawable::erase_rect(const Rect& rect, rgb32_t color)
+{
+    RECT r;
+    r.left = rect.left + _origin.x;
+    r.right = rect.right + _origin.x;
+    r.top = rect.top + _origin.y;
+    r.bottom = rect.bottom + _origin.y;
+
+    PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+    Lock lock(*dest_p_data->_mutex);
+    FillRect(dest_p_data->dc, &r, (HBRUSH)GetStockObject(BLACK_BRUSH));
+}
+
+void RedDrawable::fill_rect(const Rect& rect, rgb32_t color)
+{
+    RECT r;
+    r.left = rect.left + _origin.x;
+    r.right = rect.right + _origin.x;
+    r.top = rect.top + _origin.y;
+    r.bottom = rect.bottom + _origin.y;
+
+    HBRUSH brush = CreateSolidBrush(RGB(rgb32_get_red(color),
+                                        rgb32_get_green(color),
+                                        rgb32_get_blue(color)));
+    for (;;) {
+        PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+        Lock lock(*dest_p_data->_mutex);
+        FillRect(dest_p_data->dc, &r, brush);
+        break;
+    }
+    DeleteObject(brush);
+}
+
+void RedDrawable::frame_rect(const Rect& rect, rgb32_t color)
+{
+    RECT r;
+    r.left = rect.left + _origin.x;
+    r.right = rect.right + _origin.x;
+    r.top = rect.top + _origin.y;
+    r.bottom = rect.bottom + _origin.y;
+    HBRUSH brush = CreateSolidBrush(RGB(rgb32_get_red(color),
+                                        rgb32_get_green(color),
+                                        rgb32_get_blue(color)));
+    for (;;) {
+        PixelsSource_p* dest_p_data = (PixelsSource_p*)get_opaque();
+        Lock lock(*dest_p_data->_mutex);
+        FrameRect(dest_p_data->dc, &r, brush);
+        break;
+    }
+    DeleteObject(brush);
+}
+
diff --git a/client/windows/red_pixmap.cpp b/client/windows/red_pixmap.cpp
new file mode 100644
index 00000000..bd9d7e41
--- /dev/null
+++ b/client/windows/red_pixmap.cpp
@@ -0,0 +1,42 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_pixmap.h"
+#include "debug.h"
+#include "utils.h"
+
+RedPixmap::RedPixmap(int width, int height, RedPixmap::Format format,
+                     bool top_bottom, rgb32_t* pallet)
+    : _format (format)
+    , _width (width)
+    , _height (height)
+    , _stride (ALIGN(width * (_format == RedPixmap::A1 ? 1: 32), 32) / 8)
+    , _top_bottom (top_bottom)
+    , _data (NULL)
+{
+}
+
+RedPixmap::~RedPixmap()
+{
+}
+
+bool RedPixmap::is_big_endian_bits()
+{
+    return _format == RedPixmap::A1;
+}
+
diff --git a/client/windows/red_pixmap_cairo.cpp b/client/windows/red_pixmap_cairo.cpp
new file mode 100644
index 00000000..0b3073c4
--- /dev/null
+++ b/client/windows/red_pixmap_cairo.cpp
@@ -0,0 +1,101 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_pixmap_cairo.h"
+#include "red_pixmap.h"
+#include "debug.h"
+#include "utils.h"
+#include "pixels_source_p.h"
+#include "platform_utils.h"
+
+struct RedPixmap_p {
+    PixelsSource_p pixels_source_p;
+    HBITMAP prev_bitmap;
+};
+
+static inline int format_to_bpp(RedPixmap::Format format)
+{
+    return ((format == RedPixmap::A1) ? 1 : 32);
+}
+
+RedPixmapCairo::RedPixmapCairo(int width, int height, RedPixmap::Format format, bool top_bottom,
+                               rgb32_t* pallet, RedWindow *win)
+    : RedPixmap(width, height, format, top_bottom, pallet)
+{
+    ASSERT(format == RedPixmap::ARGB32 || format == RedPixmap::RGB32 || format == RedPixmap::A1);
+    ASSERT(sizeof(RedPixmap_p) <= PIXELES_SOURCE_OPAQUE_SIZE);
+
+    struct {
+        BITMAPINFO inf;
+        RGBQUAD palette[255];
+    } bitmap_info;
+
+    memset(&bitmap_info, 0, sizeof(bitmap_info));
+    bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+    bitmap_info.inf.bmiHeader.biWidth = _width;
+    bitmap_info.inf.bmiHeader.biHeight = top_bottom ? -_height : _height;
+
+/*#ifdef USE_OGL
+    // -----------------------------------------------------------------------------
+    // ensure valid access to additional stride.
+    // apparently glReadPixels validate ((ptr of last line) + GL_PACK_ROW_LENGTH + 1).
+    // seen on "ATI Radeon HD 2400 PRO" "2.0.6479 Release"
+    if (top_bottom) {
+        bitmap_info.inf.bmiHeader.biHeight--;
+    } else {
+        bitmap_info.inf.bmiHeader.biHeight++;
+    }
+    //------------------------------------------------------------------------------
+#endif*/
+
+    bitmap_info.inf.bmiHeader.biPlanes = 1;
+    bitmap_info.inf.bmiHeader.biBitCount = format_to_bpp(format);
+    bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+    switch (format) {
+    case RedPixmap::A1:
+        for (int i = 0; i < (1 << format_to_bpp(format)); i++) {
+            bitmap_info.inf.bmiColors[i].rgbRed = rgb32_get_red(pallet[i]);
+            bitmap_info.inf.bmiColors[i].rgbGreen = rgb32_get_green(pallet[i]);
+            bitmap_info.inf.bmiColors[i].rgbBlue = rgb32_get_blue(pallet[i]);
+        }
+        break;
+    }
+    AutoDC dc(create_compatible_dc());
+    AutoGDIObject bitmap(CreateDIBSection(dc.get(), &bitmap_info.inf, 0,
+                                          (VOID **)&_data, NULL, 0));
+    if (!bitmap.valid()) {
+        THROW("create compatible bitmap failed");
+    }
+/*#ifdef USE_OGL
+    SetWindowOrgEx(dc.get(), 0, -1, NULL); // compensate for one pad line
+#endif*/
+    ((RedPixmap_p*)get_opaque())->prev_bitmap = (HBITMAP)SelectObject(dc.get(), bitmap.release());
+    ((RedPixmap_p*)get_opaque())->pixels_source_p.dc = dc.release();
+}
+
+RedPixmapCairo::~RedPixmapCairo()
+{
+    HDC dc = ((RedPixmap_p*)get_opaque())->pixels_source_p.dc;
+    if (dc) {
+        HBITMAP prev_bitmap = ((RedPixmap_p*)get_opaque())->prev_bitmap;
+        HBITMAP bitmap = (HBITMAP)SelectObject(dc, prev_bitmap);
+        DeleteObject(bitmap);
+        DeleteDC(dc);
+    }
+}
+
diff --git a/client/windows/red_pixmap_gdi.cpp b/client/windows/red_pixmap_gdi.cpp
new file mode 100644
index 00000000..adb21da8
--- /dev/null
+++ b/client/windows/red_pixmap_gdi.cpp
@@ -0,0 +1,102 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_pixmap_gdi.h"
+#include "red_pixmap.h"
+#include "debug.h"
+#include "utils.h"
+#include "pixels_source_p.h"
+#include "platform_utils.h"
+
+struct RedPixmap_p {
+    PixelsSource_p pixels_source_p;
+    HBITMAP prev_bitmap;
+};
+
+static inline int format_to_bpp(RedPixmap::Format format)
+{
+    return ((format == RedPixmap::A1) ? 1 : 32);
+}
+
+RedPixmapGdi::RedPixmapGdi(int width, int height, RedPixmap::Format format, bool top_bottom,
+                           rgb32_t* pallet)
+    : RedPixmap(width, height, format, top_bottom, pallet)
+{
+    ASSERT(format == RedPixmap::ARGB32 || format == RedPixmap::RGB32 || format == RedPixmap::A1);
+    ASSERT(sizeof(RedPixmap_p) <= PIXELES_SOURCE_OPAQUE_SIZE);
+
+    struct {
+        BITMAPINFO inf;
+        RGBQUAD palette[255];
+    } bitmap_info;
+
+    memset(&bitmap_info, 0, sizeof(bitmap_info));
+    bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+    bitmap_info.inf.bmiHeader.biWidth = _width;
+    bitmap_info.inf.bmiHeader.biHeight = top_bottom ? -_height : _height;
+
+    bitmap_info.inf.bmiHeader.biPlanes = 1;
+    bitmap_info.inf.bmiHeader.biBitCount = format_to_bpp(format);
+    bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+    switch (format) {
+    case RedPixmap::A1:
+        for (int i = 0; i < (1 << format_to_bpp(format)); i++) {
+            bitmap_info.inf.bmiColors[i].rgbRed = rgb32_get_red(pallet[i]);
+            bitmap_info.inf.bmiColors[i].rgbGreen = rgb32_get_green(pallet[i]);
+            bitmap_info.inf.bmiColors[i].rgbBlue = rgb32_get_blue(pallet[i]);
+        }
+        break;
+    }
+    AutoDC dc(create_compatible_dc());
+    AutoGDIObject bitmap(CreateDIBSection(dc.get(), &bitmap_info.inf, 0,
+                                          (VOID **)&_data, NULL, 0));
+    if (!bitmap.valid()) {
+        THROW("create compatible bitmap failed");
+    }
+    memset(_data, 1, 1);
+    ((RedPixmap_p*)get_opaque())->prev_bitmap = (HBITMAP)SelectObject(dc.get(), bitmap.release());
+    ((RedPixmap_p*)get_opaque())->pixels_source_p.dc = dc.release();
+}
+
+HDC RedPixmapGdi::get_dc()
+{
+    return ((RedPixmap_p*)get_opaque())->pixels_source_p.dc;
+}
+
+void *RedPixmapGdi::get_memptr()
+{
+    return _data;
+}
+
+RedPixmapGdi::~RedPixmapGdi()
+{
+    HDC dc = ((RedPixmap_p*)get_opaque())->pixels_source_p.dc;
+    if (dc) {
+        HBITMAP prev_bitmap = ((RedPixmap_p*)get_opaque())->prev_bitmap;
+        HBITMAP bitmap = (HBITMAP)SelectObject(dc, prev_bitmap);
+        DeleteObject(bitmap);
+        DeleteDC(dc);
+    }
+}
+
+Mutex& RedPixmapGdi::get_mutex()
+{
+    RedPixmap_p* p_data = (RedPixmap_p*)get_opaque();
+    return *p_data->pixels_source_p._mutex;
+}
+
diff --git a/client/windows/red_window.cpp b/client/windows/red_window.cpp
new file mode 100644
index 00000000..0b25a798
--- /dev/null
+++ b/client/windows/red_window.cpp
@@ -0,0 +1,933 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_window.h"
+#include "pixels_source_p.h"
+#include "utils.h"
+#include "debug.h"
+#include "red.h"
+#include "menu.h"
+#include "win_platform.h"
+#include "platform_utils.h"
+
+#define NATIVE_CAPTION_STYLE (WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)
+
+extern HINSTANCE instance;
+
+static ATOM class_atom = 0;
+static const LPCWSTR win_class_name = L"redc_wclass";
+static HWND focus_window = NULL;
+static HHOOK low_keyboard_hook = NULL;
+
+
+static inline int to_red_mouse_state(WPARAM wParam)
+{
+    return ((wParam & MK_LBUTTON) ? REDC_LBUTTON_MASK : 0) |
+           ((wParam & MK_MBUTTON) ? REDC_MBUTTON_MASK : 0) |
+           ((wParam & MK_RBUTTON) ? REDC_RBUTTON_MASK : 0);
+}
+
+static inline RedKey translate_key(int virtual_key, uint32_t scan, bool escape)
+{
+    if (scan == 0) {
+        return REDKEY_INVALID;
+    }
+    switch (virtual_key) {
+    case VK_PAUSE:
+        return REDKEY_PAUSE;
+    case VK_SNAPSHOT:
+        return REDKEY_CTRL_PRINT_SCREEN;
+    case VK_NUMLOCK:
+        return REDKEY_NUM_LOCK;
+    case VK_HANGUL:
+        return REDKEY_KOREAN_HANGUL;
+    case VK_HANJA:
+        return REDKEY_KOREAN_HANGUL_HANJA;
+    case VK_PROCESSKEY:
+        if (scan == 0xf1) {
+            return REDKEY_INVALID; // prevent double key (VK_PROCESSKEY + VK_HANJA)
+        } else if (scan == 0xf2) {
+            return REDKEY_KOREAN_HANGUL;
+        }
+    default:
+        //todo: always use vitrtual key
+        if (escape) {
+            scan += REDKEY_ESCAPE_BASE;
+        }
+        return (RedKey)scan;
+    }
+}
+
+static int menu_cmd_to_app(WPARAM wparam)
+{
+    return 0;
+}
+
+LRESULT CALLBACK RedWindow_p::WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+    RedWindow* window = (RedWindow*)GetWindowLong(hWnd, GWL_USERDATA);
+    ASSERT(window);
+
+    switch (message) {
+    case WM_PAINT: {
+        PAINTSTRUCT ps;
+        HDC hdc;
+
+        hdc = BeginPaint(hWnd, &ps);
+        Point origin = window->get_origin();
+        Rect r;
+        r.left = ps.rcPaint.left - origin.x;
+        r.top = ps.rcPaint.top - origin.y;
+        r.right = ps.rcPaint.right - origin.x;
+        r.bottom = ps.rcPaint.bottom - origin.y;
+        window->get_listener().on_exposed_rect(r);
+        EndPaint(hWnd, &ps);
+        break;
+    }
+    case WM_MOUSEMOVE: {
+        if (!window->_pointer_in_window) {
+            window->on_pointer_enter();
+        }
+        Point origin = window->get_origin();
+        window->get_listener().on_mouse_motion(LOWORD(lParam) - origin.x, HIWORD(lParam) - origin.y,
+                                               to_red_mouse_state(wParam));
+        break;
+    }
+    case WM_MOUSELEAVE:
+        window->on_pointer_leave();
+        break;
+    case WM_SETFOCUS:
+        window->on_focus_in();
+        break;
+    case WM_KILLFOCUS:
+        window->on_focus_out();
+        break;
+    case WM_LBUTTONDOWN:
+        window->get_listener().on_button_press(REDC_MOUSE_LBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_LBUTTONUP:
+        window->get_listener().on_button_release(REDC_MOUSE_LBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_RBUTTONDOWN:
+        window->get_listener().on_button_press(REDC_MOUSE_RBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_RBUTTONUP:
+        window->get_listener().on_button_release(REDC_MOUSE_RBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_MBUTTONDOWN:
+        window->get_listener().on_button_press(REDC_MOUSE_MBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_MBUTTONUP:
+        window->get_listener().on_button_release(REDC_MOUSE_MBUTTON, to_red_mouse_state(wParam));
+        break;
+    case WM_MOUSEWHEEL:
+        if (HIWORD(wParam) & 0x8000) {
+            window->get_listener().on_button_press(REDC_MOUSE_DBUTTON,
+                                                   to_red_mouse_state(wParam));
+            window->get_listener().on_button_release(REDC_MOUSE_DBUTTON,
+                                                     to_red_mouse_state(wParam));
+        } else {
+            window->get_listener().on_button_press(REDC_MOUSE_UBUTTON,
+                                                   to_red_mouse_state(wParam));
+            window->get_listener().on_button_release(REDC_MOUSE_UBUTTON,
+                                                     to_red_mouse_state(wParam));
+        }
+        break;
+    case WM_SYSKEYDOWN:
+    case WM_KEYDOWN: {
+        RedKey key = translate_key(wParam, HIWORD(lParam) & 0xff, (lParam & (1 << 24)) != 0);
+        window->get_listener().on_key_press(key);
+        // Allow Windows to translate Alt-F4 to WM_CLOSE message.
+        if (!window->_key_interception) {
+            return DefWindowProc(hWnd, message, wParam, lParam);
+        }
+        break;
+    }
+    case WM_SYSKEYUP:
+    case WM_KEYUP: {
+        RedKey key = translate_key(wParam, HIWORD(lParam) & 0xff, (lParam & (1 << 24)) != 0);
+        window->get_listener().on_key_release(key);
+        break;
+    }
+    case WM_ACTIVATE:
+        if (LOWORD(wParam) == WA_INACTIVE) {
+            window->get_listener().on_deactivate();
+        } else {
+            window->get_listener().on_activate();
+        }
+        break;
+    case WM_DESTROY:
+        PostQuitMessage(0);
+        break;
+    case WM_GETMINMAXINFO: {
+        MINMAXINFO* info = (MINMAXINFO*)lParam;
+        info->ptMaxSize.x = window->_window_size.x;
+        info->ptMaxSize.y = window->_window_size.y;
+        info->ptMinTrackSize = info->ptMaxSize;
+        info->ptMaxTrackSize = info->ptMaxSize;
+        info->ptMaxPosition.x = info->ptMaxPosition.y = 0;
+        break;
+    }
+    case WM_SYSCOMMAND:
+        if (window->prossec_menu_commands(wParam & ~0x0f)) {
+            break;
+        }
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    case WM_ENTERSIZEMOVE:
+    case WM_ENTERMENULOOP:
+        window->get_listener().enter_modal_loop();
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    case WM_EXITSIZEMOVE:
+    case WM_EXITMENULOOP:
+        window->get_listener().exit_modal_loop();
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    case WM_SETCURSOR:
+        if (!window->_pointer_in_window) {
+            return DefWindowProc(hWnd, message, wParam, lParam);
+        }
+        break;
+    case WM_SIZE:
+        if (wParam == SIZE_MINIMIZED) {
+            window->on_minimized();
+        } else if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED) {
+            window->on_restored();
+        }
+        break;
+    case WM_WINDOWPOSCHANGING:
+        window->on_pos_changing(*window);
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    default:
+        return DefWindowProc(hWnd, message, wParam, lParam);
+    }
+    return 0;
+}
+
+static ATOM register_class(HINSTANCE instance)
+{
+    WNDCLASSEX wclass;
+
+    wclass.cbSize = sizeof(WNDCLASSEX);
+    wclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+    wclass.lpfnWndProc = DefWindowProc;
+    wclass.cbClsExtra = 0;
+    wclass.cbWndExtra = 0;
+    wclass.hInstance = instance;
+    wclass.hIcon = NULL;
+    wclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wclass.hbrBackground = NULL;
+    wclass.lpszMenuName = NULL;
+    wclass.lpszClassName = win_class_name;
+    wclass.hIconSm = NULL;
+    return RegisterClassEx(&wclass);
+}
+
+RedWindow_p::RedWindow_p()
+    : _win (NULL)
+    , _modal_refs (0)
+    , _no_taskmgr_dll (NULL)
+    , _no_taskmgr_hook (NULL)
+    , _minimized (false)
+    , _valid_pos (false)
+    , _sys_menu (NULL)
+{
+}
+
+void RedWindow_p::create(RedWindow& red_window, PixelsSource_p& pixels_source)
+{
+    HWND window;
+    if (!(window = CreateWindow(win_class_name, L"", NATIVE_CAPTION_STYLE, CW_USEDEFAULT,
+                                0, CW_USEDEFAULT, 0, NULL, NULL, NULL, NULL))) {
+        THROW("create window failed");
+    }
+    HDC dc = GetDC(window);
+    if (!dc) {
+        THROW("get dc failed");
+    }
+    _win = window;
+    pixels_source.dc = dc;
+    SetWindowLong(window, GWL_USERDATA, (LONG)&red_window);
+    SetWindowLong(window, GWL_WNDPROC, (LONG)WindowProc);
+}
+
+void RedWindow_p::destroy(PixelsSource_p& pixels_source)
+{
+    if (!_win) {
+        return;
+    }
+
+    ReleaseDC(_win, pixels_source.dc);
+    SetWindowLong(_win, GWL_WNDPROC, (LONG)DefWindowProc);
+    SetWindowLong(_win, GWL_USERDATA, NULL);
+    DestroyWindow(_win);
+}
+
+void RedWindow_p::on_pos_changing(RedWindow& red_window)
+{
+    if (_minimized || IsIconic(_win)) {
+        return;
+    }
+    Point pos = red_window.get_position();
+    _x = pos.x;
+    _y = pos.y;
+    _valid_pos = true;
+}
+
+void RedWindow_p::on_minimized()
+{
+    _minimized = true;
+}
+
+void RedWindow_p::on_restored()
+{
+    if (!_minimized) {
+        return;
+    }
+    _minimized = false;
+    if (!_valid_pos) {
+        return;
+    }
+    _valid_pos = false;
+    SetWindowPos(_win, NULL, _x, _y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
+}
+
+bool RedWindow_p::prossec_menu_commands(int cmd)
+{
+    CommandMap::iterator iter = _commands_map.find(cmd);
+    if (iter == _commands_map.end()) {
+        return false;
+    }
+    (*iter).second.menu->get_target().do_command((*iter).second.command);
+    return true;
+}
+
+RedWindow::RedWindow(RedWindow::Listener& listener, int screen_id)
+    : _listener (listener)
+    , _type (TYPE_NORMAL)
+    , _local_cursor (NULL)
+    , _cursor_visible (true)
+    , _focused (false)
+    , _pointer_in_window (false)
+    , _key_interception (false)
+    , _menu (NULL)
+{
+    RECT win_rect;
+
+    create(*this, *(PixelsSource_p*)get_opaque());
+    GetWindowRect(_win, &win_rect);
+    _window_size.x = win_rect.right - win_rect.left;
+    _window_size.y = win_rect.bottom - win_rect.top;
+}
+
+RedWindow::~RedWindow()
+{
+    release_menu(_menu);
+    destroy(*(PixelsSource_p*)get_opaque());
+    if (_local_cursor) {
+        _local_cursor->unref();
+    }
+}
+
+void RedWindow::set_title(std::wstring& title)
+{
+    SetWindowText(_win, title.c_str());
+}
+
+void RedWindow::set_icon(Icon* icon)
+{
+    if (!icon) {
+        return;
+    }
+    WinIcon* w_icon = (WinIcon *)icon;
+    SendMessage(_win, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)w_icon->get_handle());
+    SendMessage(_win, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)w_icon->get_handle());
+}
+
+void RedWindow::raise()
+{
+    SetWindowPos(_win, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+
+void RedWindow::position_after(RedWindow *win)
+{
+    HWND after = NULL;
+
+    if (win) {
+        after = win->_win;
+    }
+    SetWindowPos(_win, after, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+
+static LONG to_native_style(RedWindow::Type type)
+{
+    LONG win_style;
+
+    switch (type) {
+    case RedWindow::TYPE_NORMAL:
+        win_style = NATIVE_CAPTION_STYLE;
+        break;
+    case RedWindow::TYPE_FULLSCREEN:
+        win_style = 0;
+        break;
+    default:
+        THROW("invalid type %d", type);
+    }
+    return win_style;
+}
+
+void RedWindow::show(int screen_id)
+{
+    if (IsIconic(_win)) {
+        ShowWindow(_win, SW_RESTORE);
+    }
+
+    const UINT set_pos_flags = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW |
+                               SWP_FRAMECHANGED;
+    HWND pos;
+
+    SetWindowLong(_win, GWL_STYLE, to_native_style(_type));
+    switch (_type) {
+    case TYPE_NORMAL:
+        pos = HWND_NOTOPMOST;
+        break;
+    case TYPE_FULLSCREEN:
+        pos = HWND_TOPMOST;
+        break;
+    default:
+        THROW("invalid type %d", _type);
+    }
+    SetWindowPos(_win, pos, 0, 0, 0, 0, set_pos_flags);
+}
+
+void RedWindow::external_show()
+{
+    LONG_PTR style = ::GetWindowLongPtr(_win, GWL_STYLE);
+    if ((style & WS_MINIMIZE) == WS_MINIMIZE) {
+        ShowWindow(_win, SW_RESTORE);
+    } else {
+        // Handle the case when hide() was called and the window is not
+        // visible. Since we're not the active window, the call just set the
+        // windows' style and doesn't show the window.
+        if ((style & WS_VISIBLE) != WS_VISIBLE) {
+            show(0);
+        }
+        // We're not the active the window, so we must be attached to the
+        // calling thread's message queue before focus is grabbed.
+        HWND front = GetForegroundWindow();
+        if (front != NULL) {
+            DWORD thread = GetWindowThreadProcessId(front, NULL);
+            AttachThreadInput(thread, GetCurrentThreadId(), TRUE);
+            SetFocus(_win);
+            AttachThreadInput(thread, GetCurrentThreadId(), FALSE);
+        }
+    }
+}
+
+void RedWindow::hide()
+{
+    ShowWindow(_win, SW_HIDE);
+}
+
+static void client_to_window_size(HWND win, int width, int height, Point& win_size,
+                                  RedWindow::Type type)
+{
+    RECT area;
+
+    SetRect(&area, 0, 0, width, height);
+    AdjustWindowRectEx(&area, to_native_style(type), FALSE, GetWindowLong(win, GWL_EXSTYLE));
+    win_size.x = area.right - area.left;
+    win_size.y = area.bottom - area.top;
+}
+
+void RedWindow::move_and_resize(int x, int y, int width, int height)
+{
+    client_to_window_size(_win, width, height, _window_size, _type);
+    SetWindowPos(_win, NULL, x, y, _window_size.x, _window_size.y, SWP_NOACTIVATE | SWP_NOZORDER);
+    if (_minimized) {
+        _valid_pos = true;
+        _x = x;
+        _y = y;
+    }
+}
+
+void RedWindow::move(int x, int y)
+{
+    SetWindowPos(_win, NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
+    if (_minimized) {
+        _valid_pos = true;
+        _x = x;
+        _y = y;
+    }
+}
+
+void RedWindow::resize(int width, int height)
+{
+    client_to_window_size(_win, width, height, _window_size, _type);
+    SetWindowPos(_win, NULL, 0, 0, _window_size.x, _window_size.y,
+                 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER);
+}
+
+void RedWindow::activate()
+{
+    SetActiveWindow(_win);
+}
+
+void RedWindow::minimize()
+{
+    ShowWindow(_win, SW_SHOWMINIMIZED);
+}
+
+void RedWindow::set_mouse_position(int x, int y)
+{
+    POINT pt;
+    pt.x = x + get_origin().x;
+    pt.y = y + get_origin().y;
+    ClientToScreen(_win, &pt);
+    SetCursorPos(pt.x, pt.y);
+}
+
+class Region_p {
+public:
+    Region_p(HRGN region) : _region (region) {}
+    ~Region_p() {}
+
+    void get_bbox(Rect& bbox) const
+    {
+        RECT box;
+
+        if (GetRgnBox(_region, &box) == 0) {
+            THROW("get region bbox failed");
+        }
+        bbox.left = box.left;
+        bbox.right = box.right;
+        bbox.top = box.top;
+        bbox.bottom = box.bottom;
+    }
+
+    bool contains_point(int x, int y) const
+    {
+        return !!PtInRegion(_region, x, y);
+    }
+
+private:
+    HRGN _region;
+};
+
+bool RedWindow::get_mouse_anchor_point(Point& pt)
+{
+    AutoGDIObject region(CreateRectRgn(0, 0, 0, 0));
+    WindowDC win_dc(_win);
+
+    GetRandomRgn(*win_dc, (HRGN)region.get(), SYSRGN);
+    Point anchor;
+    Region_p region_p((HRGN)region.get());
+    if (!find_anchor_point(region_p, anchor)) {
+        return false;
+    }
+    POINT screen_pt;
+    screen_pt.x = anchor.x;
+    screen_pt.y = anchor.y;
+    ScreenToClient(_win, &screen_pt);
+    pt.x = screen_pt.x - get_origin().x;
+    pt.y = screen_pt.y - get_origin().y;
+    return true;
+}
+
+void RedWindow::cupture_mouse()
+{
+    RECT client_rect;
+    POINT origin;
+
+    origin.x = origin.y = 0;
+    ClientToScreen(_win, &origin);
+    GetClientRect(_win, &client_rect);
+    OffsetRect(&client_rect, origin.x, origin.y);
+    ClipCursor(&client_rect);
+}
+
+void RedWindow::release_mouse()
+{
+    ClipCursor(NULL);
+}
+
+void RedWindow::set_cursor(LocalCursor* local_cursor)
+{
+    ASSERT(local_cursor);
+    if (_local_cursor) {
+        _local_cursor->unref();
+    }
+    _local_cursor = local_cursor->ref();
+    if (_pointer_in_window) {
+        _local_cursor->set(_win);
+        while (ShowCursor(TRUE) < 0);
+    }
+    _cursor_visible = true;
+}
+
+void RedWindow::hide_cursor()
+{
+    if (_cursor_visible) {
+        if (_pointer_in_window) {
+            while (ShowCursor(FALSE) > -1);
+        }
+        _cursor_visible = false;
+    }
+}
+
+void RedWindow::show_cursor()
+{
+    if (!_cursor_visible) {
+        if (_pointer_in_window) {
+            while (ShowCursor(TRUE) < 0);
+        }
+        _cursor_visible = true;
+    }
+}
+
+Point RedWindow::get_position()
+{
+    Point position;
+    if (_minimized || IsIconic(_win)) {
+        if (_valid_pos) {
+            position.x = _x;
+            position.y = _y;
+        } else {
+            position.x = position.y = 0;
+        }
+    } else {
+        RECT window_rect;
+        GetWindowRect(_win, &window_rect);
+        position.x = window_rect.left;
+        position.y = window_rect.top;
+    }
+    return position;
+}
+
+Point RedWindow::get_size()
+{
+    RECT client_rect;
+    GetClientRect(_win, &client_rect);
+    Point pt = {client_rect.right - client_rect.left, client_rect.bottom - client_rect.top};
+    return pt;
+}
+
+static LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if ((nCode == HC_ACTION)) {
+        KBDLLHOOKSTRUCT *hooked = (KBDLLHOOKSTRUCT*)lParam;
+        DWORD dwMsg = 1;
+
+        //  dwMsg shall contain the information that would be stored
+        //  in the usual lParam argument of a WM_KEYDOWN message.
+        //  All information like hardware scan code and other flags
+        //  are stored within one double word at different bit offsets.
+        //  Refer to MSDN for further information:
+        //
+        //  (Keystroke Messages)
+        dwMsg += hooked->scanCode << 16;
+        dwMsg += hooked->flags << 24;
+
+        // Forward these keys so the keyboard leds will light up.
+        BOOL bNextHook = ((hooked->vkCode == VK_CAPITAL) ||
+                          (hooked->vkCode == VK_SCROLL) || (hooked->vkCode == VK_NUMLOCK));
+
+        // In some cases scan code of VK_RSHIFT is fake shift (probably a bug) so we
+        // convert it to non extended code. Also, QEmu doesn't expect num-lock to be
+        // an extended key.
+        if ((hooked->vkCode == VK_NUMLOCK) || (hooked->vkCode == VK_RSHIFT)) {
+            dwMsg &= ~(1 << 24);
+        }
+
+        SendMessage(focus_window, wParam, hooked->vkCode, dwMsg);
+
+        if (bNextHook == FALSE) {
+            return 1;
+        }
+    }
+
+    // In all other cases, we call the next hook and return it's value.
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+void RedWindow::do_start_key_interception()
+{
+    if (low_keyboard_hook) {
+        return;
+    }
+    low_keyboard_hook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc,
+                                         GetModuleHandle(NULL), 0);
+    _listener.on_start_key_interception();
+}
+
+void RedWindow::do_stop_key_interception()
+{
+    if (!low_keyboard_hook) {
+        return;
+    }
+
+    UnhookWindowsHookEx(low_keyboard_hook);
+    low_keyboard_hook = NULL;
+    _listener.on_stop_key_interception();
+}
+
+void RedWindow::start_key_interception()
+{
+    if (_key_interception) {
+        return;
+    }
+    _key_interception = true;
+    focus_window = _win;
+    if (_focused && _pointer_in_window) {
+        do_start_key_interception();
+    }
+}
+
+void RedWindow::stop_key_interception()
+{
+    if (!_key_interception) {
+        return;
+    }
+    _key_interception = false;
+    if (_focused && _pointer_in_window) {
+        do_stop_key_interception();
+    }
+}
+
+void RedWindow::init()
+{
+    if (!(class_atom = register_class(instance))) {
+        THROW("register class failed");
+    }
+}
+
+#ifdef USE_OGL
+
+void RedWindow::touch_context_draw()
+{
+}
+
+void RedWindow::touch_context_copy()
+{
+}
+
+void RedWindow::untouch_context()
+{
+}
+
+#endif
+
+void RedWindow::set_type_gl()
+{
+}
+
+void RedWindow::unset_type_gl()
+{
+}
+
+void RedWindow::on_focus_in()
+{
+    _focused = true;
+    if (_pointer_in_window && _key_interception) {
+        do_start_key_interception();
+    }
+}
+
+void RedWindow::on_focus_out()
+{
+    if (!_focused) {
+        return;
+    }
+    _focused = false;
+    do_stop_key_interception();
+}
+
+void RedWindow::on_pointer_enter()
+{
+    if (_pointer_in_window) {
+        return;
+    }
+    if (_cursor_visible) {
+        if (_local_cursor) {
+            _local_cursor->set(_win);
+        }
+        while (ShowCursor(TRUE) < 0);
+    } else {
+        while (ShowCursor(FALSE) > -1);
+    }
+    _pointer_in_window = true;
+    _listener.on_pointer_enter();
+
+    TRACKMOUSEEVENT tme;
+    tme.cbSize = sizeof(TRACKMOUSEEVENT);
+    tme.dwFlags = TME_LEAVE;
+    tme.hwndTrack = _win;
+    if (!TrackMouseEvent(&tme)) {
+        THROW("track mouse event failed");
+    }
+    if (_focused && _key_interception) {
+        do_start_key_interception();
+    }
+}
+
+void RedWindow::on_pointer_leave()
+{
+    if (!_pointer_in_window) {
+        return;
+    }
+    if (!_cursor_visible) {
+        while (ShowCursor(TRUE) < 0);
+    }
+    _pointer_in_window = false;
+    _listener.on_pointer_leave();
+    if (_focused && _key_interception) {
+        do_stop_key_interception();
+    }
+}
+
+static void insert_seperator(HMENU menu)
+{
+    MENUITEMINFO item_info;
+    item_info.cbSize = sizeof(item_info);
+    item_info.fMask = MIIM_TYPE;
+    item_info.fType = MFT_SEPARATOR;
+    item_info.dwTypeData = NULL;
+    item_info.dwItemData = 0;
+    InsertMenuItem(menu, GetMenuItemCount(menu), TRUE, &item_info);
+}
+
+static void utf8_to_wchar(const std::string& src, std::wstring& dest)
+{
+    int len = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, NULL, 0);
+    if (!len) {
+        THROW("fail to conver utf8 to wchar");
+    }
+    dest.resize(len);
+    MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, (wchar_t *)dest.c_str(), len);
+}
+
+static void insert_command(HMENU menu, const std::string& name, int id)
+{
+    MENUITEMINFO item_info;
+    item_info.cbSize = sizeof(item_info);
+    item_info.fMask = MIIM_TYPE | MIIM_ID;
+    item_info.fType = MFT_STRING;
+    std::wstring wname;
+    utf8_to_wchar(name, wname);
+    item_info.cch = wname.size();
+    item_info.dwTypeData = (wchar_t *)wname.c_str();
+    item_info.wID = id;
+    InsertMenuItem(menu, GetMenuItemCount(menu), TRUE, &item_info);
+}
+
+static HMENU insert_sub_menu(HMENU menu, const std::string& name)
+{
+    MENUITEMINFO item_info;
+    item_info.cbSize = sizeof(item_info);
+    item_info.fMask = MIIM_TYPE | MIIM_SUBMENU;
+    item_info.fType = MFT_STRING;
+    std::wstring wname;
+    utf8_to_wchar(name, wname);
+    item_info.cch = wname.size();
+    item_info.dwTypeData = (wchar_t *)wname.c_str();
+    item_info.hSubMenu = CreateMenu();
+    InsertMenuItem(menu, GetMenuItemCount(menu), TRUE, &item_info);
+    return item_info.hSubMenu;
+}
+
+static int next_free_id = 1;
+static const int last_id = 0x0f00;
+
+static std::list<int> free_sys_menu_id;
+
+static int alloc_sys_cmd_id()
+{
+    if (!free_sys_menu_id.empty()) {
+        int ret = *free_sys_menu_id.begin();
+        free_sys_menu_id.pop_front();
+        return ret;
+    }
+    if (next_free_id == last_id) {
+        THROW("failed");
+    }
+
+    return next_free_id++ << 4;
+}
+
+static void free_sys_cmd_id(int id)
+{
+    free_sys_menu_id.push_back(id >> 4);
+}
+
+static void insert_menu(Menu* menu, HMENU native, CommandMap& _commands_map)
+{
+    int pos = 0;
+
+    for (;; pos++) {
+        Menu::ItemType type = menu->item_type_at(pos);
+        switch (type) {
+        case Menu::MENU_ITEM_TYPE_COMMAND: {
+            std::string name;
+            int command_id;
+            menu->command_at(pos, name, command_id);
+            int sys_command = alloc_sys_cmd_id();
+            _commands_map[sys_command] = CommandInfo(menu, command_id);
+            insert_command(native, name, sys_command);
+            break;
+        }
+        case Menu::MENU_ITEM_TYPE_MENU: {
+            AutoRef<Menu> sub_menu(menu->sub_at(pos));
+            HMENU native_sub = insert_sub_menu(native, (*sub_menu)->get_name());
+            insert_menu(*sub_menu, native_sub, _commands_map);
+            break;
+        }
+        case Menu::MENU_ITEM_TYPE_SEPARATOR:
+            insert_seperator(native);
+            break;
+        case Menu::MENU_ITEM_TYPE_INVALID:
+            return;
+        }
+    }
+}
+
+void RedWindow_p::release_menu(Menu* menu)
+{
+    if (menu) {
+        while (!_commands_map.empty()) {
+            free_sys_cmd_id((*_commands_map.begin()).first);
+            _commands_map.erase(_commands_map.begin());
+        }
+        GetSystemMenu(_win, TRUE);
+        _sys_menu = NULL;
+        menu->unref();
+        return;
+    }
+}
+
+void RedWindow::set_menu(Menu* menu)
+{
+    release_menu(_menu);
+    _menu = NULL;
+
+    if (!menu) {
+        return;
+    }
+    _menu = menu->ref();
+    _sys_menu = GetSystemMenu(_win, FALSE);
+    insert_seperator(_sys_menu);
+    insert_menu(_menu, _sys_menu, _commands_map);
+}
+
diff --git a/client/windows/red_window_p.h b/client/windows/red_window_p.h
new file mode 100644
index 00000000..4b5655ec
--- /dev/null
+++ b/client/windows/red_window_p.h
@@ -0,0 +1,68 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_WINDOW_P
+#define _H_RED_WINDOW_P
+
+#include <map>
+
+class RedWindow;
+class Menu;
+struct PixelsSource_p;
+
+typedef HWND Window;
+
+class CommandInfo {
+public:
+    CommandInfo() : menu (0), command (NULL) {}
+    CommandInfo(Menu* in_menu, int in_command) : menu (in_menu), command (in_command) {}
+
+    Menu* menu;
+    int command;
+};
+
+typedef std::map<int, CommandInfo> CommandMap;
+
+class RedWindow_p {
+public:
+    RedWindow_p();
+
+    void create(RedWindow& red_window, PixelsSource_p& pixels_source);
+    void destroy(PixelsSource_p& pixels_source);
+    void release_menu(Menu* menu);
+    void on_minimized();
+    void on_restored();
+    void on_pos_changing(RedWindow& red_window);
+    bool prossec_menu_commands(int cmd);
+
+    static LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+protected:
+    HWND _win;
+    uint32_t _modal_refs;
+    HMODULE _no_taskmgr_dll;
+    HHOOK _no_taskmgr_hook;
+    bool _minimized;
+    bool _valid_pos;
+    int _x;
+    int _y;
+    CommandMap _commands_map;
+    HMENU _sys_menu;
+};
+
+#endif
+
diff --git a/client/windows/redc.rc b/client/windows/redc.rc
new file mode 100644
index 00000000..9524d1bd
--- /dev/null
+++ b/client/windows/redc.rc
@@ -0,0 +1,138 @@
+// Microsoft Visual C++ generated resource script.

+//

+#include "resource.h"

+

+#define APSTUDIO_READONLY_SYMBOLS

+/////////////////////////////////////////////////////////////////////////////

+//

+// Generated from the TEXTINCLUDE 2 resource.

+//

+#include "afxres.h"

+

+/////////////////////////////////////////////////////////////////////////////

+#undef APSTUDIO_READONLY_SYMBOLS

+

+/////////////////////////////////////////////////////////////////////////////

+// English (U.S.) resources

+

+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)

+#ifdef _WIN32

+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

+#pragma code_page(1252)

+#endif //_WIN32

+

+#ifdef APSTUDIO_INVOKED

+/////////////////////////////////////////////////////////////////////////////

+//

+// TEXTINCLUDE

+//

+

+1 TEXTINCLUDE 

+BEGIN

+    "resource.h\0"

+END

+

+2 TEXTINCLUDE 

+BEGIN

+    "#include ""afxres.h""\r\n"

+    "\0"

+END

+

+3 TEXTINCLUDE 

+BEGIN

+    "\r\n"

+    "\0"

+END

+

+#endif    // APSTUDIO_INVOKED

+

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// Bitmap

+//

+

+SPLASH_IMAGE_RES_ID     BITMAP                  "splash.bmp"

+INFO_IMAGE_RES_ID       BITMAP                  "static_title.bmp"

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// Version

+//

+

+VS_VERSION_INFO VERSIONINFO

+ FILEVERSION 0,3,99,0

+ PRODUCTVERSION 0,3,99,0

+ FILEFLAGSMASK 0x17L

+#ifdef _DEBUG

+ FILEFLAGS 0x1L

+#else

+ FILEFLAGS 0x0L

+#endif

+ FILEOS 0x4L

+ FILETYPE 0x1L

+ FILESUBTYPE 0x0L

+BEGIN

+    BLOCK "StringFileInfo"

+    BEGIN

+        BLOCK "000904b0"

+        BEGIN

+            VALUE "CompanyName", "Red Hat Technologies INC"

+            VALUE "FileDescription", "Spice client"

+            VALUE "FileVersion", "0, 3, 99, 0"

+            VALUE "InternalName", "spicec"

+            VALUE "LegalCopyright", "Copyright (c) 2009  Red Hat, Inc. and/or its affiliates.INC. All rights reserved."

+            VALUE "OriginalFilename", "spicec.exe"

+            VALUE "ProductName", "Red Hat Spice"

+            VALUE "ProductVersion", "0, 3, 99, 0"

+        END

+    END

+    BLOCK "VarFileInfo"

+    BEGIN

+        VALUE "Translation", 0x9, 1200

+    END

+END

+

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// Icon

+//

+

+// Icon with lowest ID value placed first to ensure application icon

+// remains consistent on all systems.

+RED_ICON_RES_ID         ICON                    "solideice.ico"

+#endif    // English (U.S.) resources

+/////////////////////////////////////////////////////////////////////////////

+

+

+/////////////////////////////////////////////////////////////////////////////

+// Neutral (Sys. Default) resources

+

+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_NEUSD)

+#ifdef _WIN32

+LANGUAGE LANG_NEUTRAL, SUBLANG_SYS_DEFAULT

+#pragma code_page(1255)

+#endif //_WIN32

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// RT_MANIFEST

+//

+

+1                       RT_MANIFEST             "spicec.exe.manifest"

+#endif    // Neutral (Sys. Default) resources

+/////////////////////////////////////////////////////////////////////////////

+

+

+

+#ifndef APSTUDIO_INVOKED

+/////////////////////////////////////////////////////////////////////////////

+//

+// Generated from the TEXTINCLUDE 3 resource.

+//

+

+

+/////////////////////////////////////////////////////////////////////////////

+#endif    // not APSTUDIO_INVOKED

+

diff --git a/client/windows/redc.sln b/client/windows/redc.sln
new file mode 100644
index 00000000..0562b95e
--- /dev/null
+++ b/client/windows/redc.sln
@@ -0,0 +1,20 @@
+

+Microsoft Visual Studio Solution File, Format Version 9.00

+# Visual Studio 2005

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "redc", "redc.vcproj", "{4F03BAF9-DFBC-4CA7-B860-8929555981AE}"

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|Win32 = Debug|Win32

+		Release|Win32 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{4F03BAF9-DFBC-4CA7-B860-8929555981AE}.Debug|Win32.ActiveCfg = Debug|Win32

+		{4F03BAF9-DFBC-4CA7-B860-8929555981AE}.Debug|Win32.Build.0 = Debug|Win32

+		{4F03BAF9-DFBC-4CA7-B860-8929555981AE}.Release|Win32.ActiveCfg = Release|Win32

+		{4F03BAF9-DFBC-4CA7-B860-8929555981AE}.Release|Win32.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/client/windows/redc.vcproj b/client/windows/redc.vcproj
new file mode 100644
index 00000000..25ff3259
--- /dev/null
+++ b/client/windows/redc.vcproj
@@ -0,0 +1,597 @@
+<?xml version="1.0" encoding="windows-1255"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="8.00"

+	Name="redc"

+	ProjectGUID="{4F03BAF9-DFBC-4CA7-B860-8929555981AE}"

+	RootNamespace="redc"

+	Keyword="Win32Proj"

+	>

+	<Platforms>

+		<Platform

+			Name="Win32"

+		/>

+	</Platforms>

+	<ToolFiles>

+	</ToolFiles>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory="$(REDC_BUILD_DIR)$(ConfigurationName)"

+			IntermediateDirectory="$(REDC_BUILD_DIR)$(ConfigurationName)"

+			ConfigurationType="1"

+			CharacterSet="1"

+			>

+			<Tool

+				Name="VCPreBuildEventTool"

+				CommandLine=""

+			/>

+			<Tool

+				Name="VCCustomBuildTool"

+			/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"

+			/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"

+			/>

+			<Tool

+				Name="VCMIDLTool"

+			/>

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories=".;..;&quot;..\..\common\win\my_getopt-1.5&quot;;..\..\common;&quot;$(SPICE_LIBS)\include&quot;;&quot;$(SPICE_LIBS)\include\qcairo&quot;;&quot;$(SPICE_LIBS)\include\ffmpeg&quot;"

+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;CAIRO_CANVAS_ACCESS_TEST;CAIRO_CANVAS_CACHE;CAIRO_CANVAS_CACH_IS_SHARED;RED_DEBUG;CAIRO_CANVAS_NO_CHUNKS;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB"

+				MinimalRebuild="false"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="1"

+				UsePrecompiledHeader="1"

+				PrecompiledHeaderThrough="common.h"

+				WarningLevel="3"

+				WarnAsError="true"

+				Detect64BitPortabilityProblems="false"

+				DebugInformationFormat="4"

+			/>

+			<Tool

+				Name="VCManagedResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCPreLinkEventTool"

+			/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="log4cppD.lib libqcairo-2.dll.lib libeay32MTd.lib ssleay32MTd.lib ws2_32.lib msimg32.lib winmm.lib avcodec-52.lib avutil-49.lib libcelt_0_5_1D.lib pthreadsD.lib version.lib"

+				OutputFile="$(OutDir)\spicec.exe"

+				LinkIncremental="2"

+				AdditionalLibraryDirectories="&quot;$(SPICE_LIBS)\lib&quot;"

+				IgnoreAllDefaultLibraries="false"

+				GenerateDebugInformation="true"

+				SubSystem="2"

+				TargetMachine="1"

+			/>

+			<Tool

+				Name="VCALinkTool"

+			/>

+			<Tool

+				Name="VCManifestTool"

+			/>

+			<Tool

+				Name="VCXDCMakeTool"

+			/>

+			<Tool

+				Name="VCBscMakeTool"

+			/>

+			<Tool

+				Name="VCFxCopTool"

+			/>

+			<Tool

+				Name="VCAppVerifierTool"

+			/>

+			<Tool

+				Name="VCWebDeploymentTool"

+			/>

+			<Tool

+				Name="VCPostBuildEventTool"

+			/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory="$(REDC_BUILD_DIR)$(ConfigurationName)"

+			IntermediateDirectory="$(REDC_BUILD_DIR)$(ConfigurationName)"

+			ConfigurationType="1"

+			CharacterSet="1"

+			WholeProgramOptimization="1"

+			>

+			<Tool

+				Name="VCPreBuildEventTool"

+				CommandLine=""

+			/>

+			<Tool

+				Name="VCCustomBuildTool"

+			/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"

+			/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"

+			/>

+			<Tool

+				Name="VCMIDLTool"

+			/>

+			<Tool

+				Name="VCCLCompilerTool"

+				AdditionalIncludeDirectories=".;..;&quot;..\..\common\win\my_getopt-1.5&quot;;..\..\common;&quot;$(SPICE_LIBS)\include&quot;;&quot;$(SPICE_LIBS)\include\qcairo&quot;;&quot;$(SPICE_LIBS)\include\ffmpeg&quot;"

+				PreprocessorDefinitions="WIN32;_WINDOWS;CAIRO_CANVAS_ACCESS_TEST;CAIRO_CANVAS_CACHE;CAIRO_CANVAS_NO_CHUNKS;CAIRO_CANVAS_CACH_IS_SHARED;_WIN32_WINNT=0x0500;LOG4CPLUS_STATIC;USE_GLZ;PTW32_STATIC_LIB"

+				RuntimeLibrary="0"

+				UsePrecompiledHeader="0"

+				WarningLevel="3"

+				WarnAsError="true"

+				Detect64BitPortabilityProblems="false"

+				DebugInformationFormat="3"

+			/>

+			<Tool

+				Name="VCManagedResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCPreLinkEventTool"

+			/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="log4cpp.lib libqcairo-2.dll.lib libeay32MT.lib ssleay32MT.lib ws2_32.lib msimg32.lib winmm.lib avcodec-52.lib avutil-49.lib libcelt_0_5_1.lib pthreads.lib version.lib"

+				OutputFile="$(OutDir)\spicec.exe"

+				LinkIncremental="1"

+				AdditionalLibraryDirectories="&quot;$(SPICE_LIBS)\lib&quot;"

+				GenerateDebugInformation="true"

+				SubSystem="2"

+				OptimizeReferences="2"

+				EnableCOMDATFolding="2"

+				TargetMachine="1"

+			/>

+			<Tool

+				Name="VCALinkTool"

+			/>

+			<Tool

+				Name="VCManifestTool"

+			/>

+			<Tool

+				Name="VCXDCMakeTool"

+			/>

+			<Tool

+				Name="VCBscMakeTool"

+			/>

+			<Tool

+				Name="VCFxCopTool"

+			/>

+			<Tool

+				Name="VCAppVerifierTool"

+			/>

+			<Tool

+				Name="VCWebDeploymentTool"

+			/>

+			<Tool

+				Name="VCPostBuildEventTool"

+			/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<Filter

+			Name="Source Files"

+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"

+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"

+			>

+			<File

+				RelativePath="..\application.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\cairo_canvas.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\canvas.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\canvas_utils.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\cmd_line_parser.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\cursor.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\cursor_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\display_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\events_loop_p.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\gdi_canvas.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoder.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoder_window.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\hot_keys.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\inputs_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\lz.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\main.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\menu.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\monitor.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\my_getopt.cpp"

+				>

+				<FileConfiguration

+					Name="Debug|Win32"

+					>

+					<Tool

+						Name="VCCLCompilerTool"

+						ObjectFile="$(IntDir)\$(InputName)1.obj"

+						XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"

+					/>

+				</FileConfiguration>

+				<FileConfiguration

+					Name="Release|Win32"

+					>

+					<Tool

+						Name="VCCLCompilerTool"

+						ObjectFile="$(IntDir)\$(InputName)1.obj"

+						XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"

+					/>

+				</FileConfiguration>

+			</File>

+			<File

+				RelativePath=".\named_pipe.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\pixels_source.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\platform.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\platform_utils.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\playback.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\playback_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\quic.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\record.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\record_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\red_cairo_canvas.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\red_channel.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\red_client.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\red_drawable.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\red_gdi_canvas.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\red_peer.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\red_pixmap.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\red_pixmap_cairo.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\red_pixmap_gdi.cpp"

+				>

+			</File>

+			<File

+				RelativePath=".\red_window.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\region.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\rop3.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\screen.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\screen_layer.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\threads.cpp"

+				>

+			</File>

+			<File

+				RelativePath="..\utils.cpp"

+				>

+			</File>

+		</Filter>

+		<Filter

+			Name="Header Files"

+			Filter="h;hpp;hxx;hm;inl;inc;xsd"

+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"

+			>

+			<File

+				RelativePath="..\application.h"

+				>

+			</File>

+			<File

+				RelativePath=".\atomic_count.h"

+				>

+			</File>

+			<File

+				RelativePath="..\cache.hpp"

+				>

+			</File>

+			<File

+				RelativePath="..\canvas.h"

+				>

+			</File>

+			<File

+				RelativePath="..\common.h"

+				>

+			</File>

+			<File

+				RelativePath="..\cursor.h"

+				>

+			</File>

+			<File

+				RelativePath="..\cursor_channel.h"

+				>

+			</File>

+			<File

+				RelativePath="..\debug.h"

+				>

+			</File>

+			<File

+				RelativePath="..\display_channel.h"

+				>

+			</File>

+			<File

+				RelativePath="..\events_loop.h"

+				>

+			</File>

+			<File

+				RelativePath=".\events_loop_p.h"

+				>

+			</File>

+			<File

+				RelativePath="..\..\common\gdi_canvas.h"

+				>

+			</File>

+			<File

+				RelativePath="..\..\common\win\my_getopt-1.5\getopt.h"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoded_image.h"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoder.h"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoder_config.h"

+				>

+			</File>

+			<File

+				RelativePath="..\glz_decoder_window.h"

+				>

+			</File>

+			<File

+				RelativePath="..\hot_keys.h"

+				>

+			</File>

+			<File

+				RelativePath="..\icon.h"

+				>

+			</File>

+			<File

+				RelativePath="..\inputs_channel.h"

+				>

+			</File>

+			<File

+				RelativePath="..\inputs_handler.h"

+				>

+			</File>

+			<File

+				RelativePath="..\menu.h"

+				>

+			</File>

+			<File

+				RelativePath="..\monitor.h"

+				>

+			</File>

+			<File

+				RelativePath=".\named_pipe.h"

+				>

+			</File>

+			<File

+				RelativePath=".\pixels_source_p.h"

+				>

+			</File>

+			<File

+				RelativePath="..\platform.h"

+				>

+			</File>

+			<File

+				RelativePath=".\platform_utils.h"

+				>

+			</File>

+			<File

+				RelativePath=".\playback.h"

+				>

+			</File>

+			<File

+				RelativePath=".\record.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_cairo_canvas.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_channel.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_client.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_drawable.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_gdi_canvas.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_key.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_peer.h"

+				>

+			</File>

+			<File

+				RelativePath="..\red_window.h"

+				>

+			</File>

+			<File

+				RelativePath=".\resource.h"

+				>

+			</File>

+			<File

+				RelativePath="..\screen.h"

+				>

+			</File>

+			<File

+				RelativePath="..\screen_layer.h"

+				>

+			</File>

+			<File

+				RelativePath="..\shared_cache.hpp"

+				>

+			</File>

+			<File

+				RelativePath="..\threads.h"

+				>

+			</File>

+			<File

+				RelativePath="..\utils.h"

+				>

+			</File>

+			<File

+				RelativePath=".\win_platform.h"

+				>

+			</File>

+		</Filter>

+		<Filter

+			Name="Resource Files"

+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"

+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"

+			>

+			<File

+				RelativePath=".\redc.rc"

+				>

+			</File>

+			<File

+				RelativePath=".\solideice.ico"

+				>

+			</File>

+			<File

+				RelativePath=".\spicec.exe.manifest"

+				>

+			</File>

+			<File

+				RelativePath=".\splash.bmp"

+				>

+			</File>

+			<File

+				RelativePath=".\static_title.bmp"

+				>

+			</File>

+		</Filter>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/client/windows/resource.h b/client/windows/resource.h
new file mode 100644
index 00000000..51ff7f28
--- /dev/null
+++ b/client/windows/resource.h
@@ -0,0 +1,19 @@
+//{{NO_DEPENDENCIES}}

+// Microsoft Visual C++ generated include file.

+// Used by redc.rc

+//

+#define RED_ICON_RES_ID                 5

+#define SPLASH_IMAGE_RES_ID             101

+#define INFO_IMAGE_RES_ID               102

+#define IDI_ICON_APPLICATION            103

+

+// Next default values for new objects

+// 

+#ifdef APSTUDIO_INVOKED

+#ifndef APSTUDIO_READONLY_SYMBOLS

+#define _APS_NEXT_RESOURCE_VALUE        106

+#define _APS_NEXT_COMMAND_VALUE         40001

+#define _APS_NEXT_CONTROL_VALUE         1001

+#define _APS_NEXT_SYMED_VALUE           101

+#endif

+#endif

diff --git a/client/windows/solideice.ico b/client/windows/solideice.ico
new file mode 100644
index 00000000..9187fb79
--- /dev/null
+++ b/client/windows/solideice.ico
diff --git a/client/windows/spicec.exe.manifest b/client/windows/spicec.exe.manifest
new file mode 100644
index 00000000..b7d1d0a4
--- /dev/null
+++ b/client/windows/spicec.exe.manifest
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>

+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">

+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">

+    <security>

+      <requestedPrivileges>

+        <requestedExecutionLevel level="asInvoker" uiAccess="false"/>

+      </requestedPrivileges>

+    </security>

+  </trustInfo>

+</assembly>

diff --git a/client/windows/splash.bmp b/client/windows/splash.bmp
new file mode 100644
index 00000000..b1fba2fe
--- /dev/null
+++ b/client/windows/splash.bmp
diff --git a/client/windows/static_title.bmp b/client/windows/static_title.bmp
new file mode 100644
index 00000000..da575ae2
--- /dev/null
+++ b/client/windows/static_title.bmp
diff --git a/client/windows/stdint.h b/client/windows/stdint.h
new file mode 100644
index 00000000..8b94f37e
--- /dev/null
+++ b/client/windows/stdint.h
@@ -0,0 +1,394 @@
+/* ISO C9x  7.18  Integer types <stdint.h>
+
+ * Based on ISO/IEC SC22/WG14 9899 Committee draft (SC22 N2794)
+
+ *
+
+ *  THIS SOFTWARE IS NOT COPYRIGHTED
+
+ *
+
+ *  Contributor: Danny Smith <danny_r_smith_2001@yahoo.co.nz>
+
+ *
+
+ *  This source code is offered for use in the public domain. You may
+
+ *  use, modify or distribute it freely.
+
+ *
+
+ *  This code is distributed in the hope that it will be useful but
+
+ *  WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
+
+ *  DISCLAIMED. This includes but is not limited to warranties of
+
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ *
+
+ *  Date: 2000-12-02
+
+ */
+
+
+
+
+
+#ifndef _STDINT_H
+
+#define _STDINT_H
+
+#define __need_wint_t
+
+#define __need_wchar_t
+
+#include <stddef.h>
+
+
+
+#ifdef _WIN32_WCE
+
+typedef _int64 int64_t;
+
+typedef unsigned _int64 uint64_t;
+
+#else
+
+typedef long long  int64_t;
+
+typedef unsigned long long   uint64_t;
+
+#endif /* _WIN32_WCE */
+
+
+
+/* 7.18.1.1  Exact-width integer types */
+
+typedef signed char int8_t;
+
+typedef unsigned char   uint8_t;
+
+typedef short  int16_t;
+
+typedef unsigned short  uint16_t;
+
+typedef int  int32_t;
+
+typedef unsigned   uint32_t;
+
+
+
+/* 7.18.1.2  Minimum-width integer types */
+
+typedef signed char int_least8_t;
+
+typedef unsigned char   uint_least8_t;
+
+typedef short  int_least16_t;
+
+typedef unsigned short  uint_least16_t;
+
+typedef int  int_least32_t;
+
+typedef unsigned   uint_least32_t;
+
+#ifndef _WIN32_WCE
+
+typedef long long  int_least64_t;
+
+typedef unsigned long long   uint_least64_t;
+
+#endif
+
+
+
+/*  7.18.1.3  Fastest minimum-width integer types 
+
+ *  Not actually guaranteed to be fastest for all purposes
+
+ *  Here we use the exact-width types for 8 and 16-bit ints. 
+
+ */
+
+typedef char int_fast8_t;
+
+typedef unsigned char uint_fast8_t;
+
+typedef short  int_fast16_t;
+
+typedef unsigned short  uint_fast16_t;
+
+typedef int  int_fast32_t;
+
+typedef unsigned  int  uint_fast32_t;
+
+#ifndef _WIN32_WCE
+
+typedef long long  int_fast64_t;
+
+typedef unsigned long long   uint_fast64_t;
+
+#endif
+
+
+
+/* 7.18.1.4  Integer types capable of holding object pointers */
+
+typedef int intptr_t;
+
+typedef unsigned uintptr_t;
+
+
+
+/* 7.18.1.5  Greatest-width integer types */
+
+#ifndef _WIN32_WCE
+
+typedef long long  intmax_t;
+
+typedef unsigned long long   uintmax_t;
+
+#endif
+
+
+
+/* 7.18.2  Limits of specified-width integer types */
+
+#if !defined ( __cplusplus) || defined (__STDC_LIMIT_MACROS)
+
+
+
+/* 7.18.2.1  Limits of exact-width integer types */
+
+#define INT8_MIN (-128) 
+
+#define INT16_MIN (-32768)
+
+#define INT32_MIN (-2147483647 - 1)
+
+#define INT64_MIN  (-9223372036854775807LL - 1)
+
+
+
+#define INT8_MAX 127
+
+#define INT16_MAX 32767
+
+#define INT32_MAX 2147483647
+
+#define INT64_MAX 9223372036854775807LL
+
+
+
+#define UINT8_MAX 0xff /* 255U */
+
+#define UINT16_MAX 0xffff /* 65535U */
+
+#define UINT32_MAX 0xffffffff  /* 4294967295U */
+
+#define UINT64_MAX 0xffffffffffffffffULL /* 18446744073709551615ULL */
+
+
+
+/* 7.18.2.2  Limits of minimum-width integer types */
+
+#define INT_LEAST8_MIN INT8_MIN
+
+#define INT_LEAST16_MIN INT16_MIN
+
+#define INT_LEAST32_MIN INT32_MIN
+
+#define INT_LEAST64_MIN INT64_MIN
+
+
+
+#define INT_LEAST8_MAX INT8_MAX
+
+#define INT_LEAST16_MAX INT16_MAX
+
+#define INT_LEAST32_MAX INT32_MAX
+
+#define INT_LEAST64_MAX INT64_MAX
+
+
+
+#define UINT_LEAST8_MAX UINT8_MAX
+
+#define UINT_LEAST16_MAX UINT16_MAX
+
+#define UINT_LEAST32_MAX UINT32_MAX
+
+#define UINT_LEAST64_MAX UINT64_MAX
+
+
+
+/* 7.18.2.3  Limits of fastest minimum-width integer types */
+
+#define INT_FAST8_MIN INT8_MIN
+
+#define INT_FAST16_MIN INT16_MIN
+
+#define INT_FAST32_MIN INT32_MIN
+
+#define INT_FAST64_MIN INT64_MIN
+
+
+
+#define INT_FAST8_MAX INT8_MAX
+
+#define INT_FAST16_MAX INT16_MAX
+
+#define INT_FAST32_MAX INT32_MAX
+
+#define INT_FAST64_MAX INT64_MAX
+
+
+
+#define UINT_FAST8_MAX UINT8_MAX
+
+#define UINT_FAST16_MAX UINT16_MAX
+
+#define UINT_FAST32_MAX UINT32_MAX
+
+#define UINT_FAST64_MAX UINT64_MAX
+
+
+
+/* 7.18.2.4  Limits of integer types capable of holding
+
+    object pointers */ 
+
+#define INTPTR_MIN INT32_MIN
+
+#define INTPTR_MAX INT32_MAX
+
+#define UINTPTR_MAX UINT32_MAX
+
+
+
+/* 7.18.2.5  Limits of greatest-width integer types */
+
+#define INTMAX_MIN INT64_MIN
+
+#define INTMAX_MAX INT64_MAX
+
+#define UINTMAX_MAX UINT64_MAX
+
+
+
+/* 7.18.3  Limits of other integer types */
+
+#define PTRDIFF_MIN INT32_MIN
+
+#define PTRDIFF_MAX INT32_MAX
+
+
+
+#define SIG_ATOMIC_MIN INT32_MIN
+
+#define SIG_ATOMIC_MAX INT32_MAX
+
+
+
+#define SIZE_MAX UINT32_MAX
+
+
+
+#ifndef WCHAR_MIN  /* also in wchar.h */ 
+
+#define WCHAR_MIN 0
+
+#define WCHAR_MAX 0xffff /* UINT16_MAX */
+
+#endif
+
+
+
+/*
+
+ * wint_t is unsigned short for compatibility with MS runtime
+
+ */
+
+#define WINT_MIN 0
+
+#define WINT_MAX 0xffff /* UINT16_MAX */
+
+
+
+#endif /* !defined ( __cplusplus) || defined __STDC_LIMIT_MACROS */
+
+
+
+
+
+/* 7.18.4  Macros for integer constants */
+
+#if !defined ( __cplusplus) || defined (__STDC_CONSTANT_MACROS)
+
+
+
+/* 7.18.4.1  Macros for minimum-width integer constants
+
+
+
+    Accoding to Douglas Gwyn <gwyn@arl.mil>:
+
+	"This spec was changed in ISO/IEC 9899:1999 TC1; in ISO/IEC
+
+	9899:1999 as initially published, the expansion was required
+
+	to be an integer constant of precisely matching type, which
+
+	is impossible to accomplish for the shorter types on most
+
+	platforms, because C99 provides no standard way to designate
+
+	an integer constant with width less than that of type int.
+
+	TC1 changed this to require just an integer constant
+
+	*expression* with *promoted* type."
+
+*/
+
+
+
+#define INT8_C(val) ((int8_t) + (val))
+
+#define UINT8_C(val) ((uint8_t) + (val##U))
+
+#define INT16_C(val) ((int16_t) + (val))
+
+#define UINT16_C(val) ((uint16_t) + (val##U))
+
+
+
+#define INT32_C(val) val##L
+
+#define UINT32_C(val) val##UL
+
+#define INT64_C(val) val##LL
+
+#define UINT64_C(val) val##ULL
+
+
+
+/* 7.18.4.2  Macros for greatest-width integer constants */
+
+#define INTMAX_C(val)  INT64_C(val)
+
+#define UINTMAX_C(val) UINT64_C(val)
+
+
+
+#endif  /* !defined ( __cplusplus) || defined __STDC_CONSTANT_MACROS */
+
+
+
+#endif
+
+
+
diff --git a/client/windows/win_platform.h b/client/windows/win_platform.h
new file mode 100644
index 00000000..ddd0cd59
--- /dev/null
+++ b/client/windows/win_platform.h
@@ -0,0 +1,50 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_WINPLATFORM
+#define _H_WINPLATFORM
+
+#include "icon.h"
+
+class EventOwner {
+public:
+    EventOwner() : _event_handle (0) {}
+    HANDLE const get_event_handle() { return _event_handle;}
+    virtual void on_event() = 0;
+
+protected:
+    HANDLE _event_handle;
+};
+
+class WinPlatform {
+public:
+    static void add_event(EventOwner& event_owner);
+    static void remove_event(EventOwner& event_owner);
+};
+
+class WinIcon: public Icon {
+public:
+    WinIcon(HICON icon) : _icon (icon) {}
+
+    HICON get_handle() {return _icon;}
+
+private:
+    HICON _icon;
+};
+
+#endif
+
diff --git a/client/x11/.gitignore b/client/x11/.gitignore
new file mode 100644
index 00000000..fbe61107
--- /dev/null
+++ b/client/x11/.gitignore
@@ -0,0 +1,10 @@
+*.la
+*.lo
+*.loT
+*.o
+.deps
+.libs
+Makefile
+Makefile.in
+setup
+spicec
\ No newline at end of file
diff --git a/client/x11/Makefile.am b/client/x11/Makefile.am
new file mode 100644
index 00000000..2bb1c853
--- /dev/null
+++ b/client/x11/Makefile.am
@@ -0,0 +1,149 @@
+NULL =
+
+SUBDIRS = images
+
+INCLUDES = \
+	-DCAIRO_CANVAS_ACCESS_TEST			\
+	-DCAIRO_CANVAS_CACHE				\
+	-DCAIRO_CANVAS_CACH_IS_SHARED			\
+	-DCAIRO_CANVAS_NO_CHUNKS			\
+	-DUSE_GLZ					\
+	-DUSE_OGL					\
+	-I. 						\
+	-I..						\
+	-I$(top_srcdir)/common				\
+	-I$(top_srcdir)/client				\
+	$(GL_CFLAGS)					\
+	$(ALSA_CFLAGS)					\
+	$(FFMPEG_CFLAGS)				\
+	$(QCAIRO_CFLAGS)				\
+	$(LOG4CPP_CFLAGS)				\
+	$(CELT051_CFLAGS)				\
+	$(SSL_CFLAGS)					\
+	$(XRANDR_CFLAGS)				\
+	$(WARN_CFLAGS)                                  \
+	$(NULL)
+
+
+RED_COMMON_SRCS = 					\
+	$(top_srcdir)/client/application.cpp		\
+	$(top_srcdir)/client/application.h		\
+	$(top_srcdir)/client/audio_channels.h		\
+	$(top_srcdir)/client/audio_devices.h		\
+	$(top_srcdir)/client/cache.hpp			\
+	$(top_srcdir)/client/cairo_canvas.cpp		\
+	$(top_srcdir)/client/canvas.cpp			\
+	$(top_srcdir)/client/canvas.h			\
+	$(top_srcdir)/client/canvas_utils.cpp		\
+	$(top_srcdir)/client/red_cairo_canvas.cpp	\
+	$(top_srcdir)/client/red_cairo_canvas.h		\
+	$(top_srcdir)/client/cmd_line_parser.cpp	\
+	$(top_srcdir)/client/cmd_line_parser.h		\
+	$(top_srcdir)/client/common.h			\
+	$(top_srcdir)/client/cursor_channel.cpp		\
+	$(top_srcdir)/client/cursor_channel.h		\
+	$(top_srcdir)/client/cursor.cpp			\
+	$(top_srcdir)/client/cursor.h			\
+	$(top_srcdir)/client/debug.h			\
+	$(top_srcdir)/client/display_channel.cpp	\
+	$(top_srcdir)/client/display_channel.h		\
+	$(top_srcdir)/client/events_loop.h		\
+	$(top_srcdir)/client/red_gl_canvas.cpp		\
+	$(top_srcdir)/client/red_gl_canvas.h		\
+	$(top_srcdir)/client/gl_canvas.cpp		\
+	$(top_srcdir)/client/glc.cpp			\
+	$(top_srcdir)/client/glz_decoded_image.h	\
+	$(top_srcdir)/client/glz_decoder_config.h	\
+	$(top_srcdir)/client/glz_decoder.cpp		\
+	$(top_srcdir)/client/glz_decoder.h		\
+	$(top_srcdir)/client/glz_decoder_window.cpp	\
+	$(top_srcdir)/client/glz_decoder_window.h	\
+	$(top_srcdir)/client/inputs_channel.cpp		\
+	$(top_srcdir)/client/inputs_channel.h		\
+	$(top_srcdir)/client/inputs_handler.h		\
+	$(top_srcdir)/client/lz.cpp			\
+	$(top_srcdir)/client/monitor.cpp		\
+	$(top_srcdir)/client/monitor.h			\
+	$(top_srcdir)/client/menu.cpp			\
+	$(top_srcdir)/client/menu.h			\
+	$(top_srcdir)/client/pixels_source.h		\
+	$(top_srcdir)/client/platform.h			\
+	$(top_srcdir)/client/playback_channel.cpp	\
+	$(top_srcdir)/client/quic.cpp			\
+	$(top_srcdir)/client/record_channel.cpp		\
+	$(top_srcdir)/client/red_channel.cpp		\
+	$(top_srcdir)/client/red_channel.h		\
+	$(top_srcdir)/client/red_client.cpp		\
+	$(top_srcdir)/client/red_client.h		\
+	$(top_srcdir)/client/red_drawable.h		\
+	$(top_srcdir)/client/red_key.h			\
+	$(top_srcdir)/client/red_peer.cpp		\
+	$(top_srcdir)/client/red_peer.h			\
+	$(top_srcdir)/client/red_pixmap_cairo.h		\
+	$(top_srcdir)/client/red_pixmap_gl.h		\
+	$(top_srcdir)/client/red_pixmap.h		\
+	$(top_srcdir)/client/red_types.h		\
+	$(top_srcdir)/client/red_window.h		\
+	$(top_srcdir)/client/region.cpp			\
+	$(top_srcdir)/client/rop3.cpp			\
+	$(top_srcdir)/client/screen.cpp			\
+	$(top_srcdir)/client/screen.h			\
+	$(top_srcdir)/client/screen_layer.cpp		\
+	$(top_srcdir)/client/screen_layer.h		\
+	$(top_srcdir)/client/shared_cache.hpp		\
+	$(top_srcdir)/client/hot_keys.cpp		\
+	$(top_srcdir)/client/hot_keys.h			\
+	$(top_srcdir)/client/threads.cpp		\
+	$(top_srcdir)/client/utils.cpp			\
+	$(top_srcdir)/client/utils.h			\
+    $(top_srcdir)/client/icon.h                        \
+	$(NULL)
+
+bin_PROGRAMS = spicec
+
+spicec_SOURCES =			\
+	atomic_count.h			\
+	events_loop_p.cpp		\
+	events_loop_p.h			\
+	main.cpp			\
+	named_pipe.h                    \
+	named_pipe.cpp                  \
+	pixels_source.cpp		\
+	pixels_source_p.h		\
+	platform.cpp			\
+	platform_utils.h                \
+	platform_utils.cpp              \
+	playback.cpp			\
+	playback.h			\
+	record.cpp			\
+	record.h			\
+	red_drawable.cpp		\
+	red_pixmap.cpp			\
+	red_pixmap_cairo.cpp		\
+	red_pixmap_gl.cpp		\
+	red_window.cpp			\
+	red_window_p.h			\
+	res.cpp				\
+	res.h				\
+	resource.h			\
+	x_icon.cpp			\
+	x_icon.h			\
+	x_platform.h			\
+	$(RED_COMMON_SRCS)		\
+	$(NULL)
+
+spicec_LDFLAGS = \
+	$(SPICEC_STATIC_LINKAGE_BSTATIC)		\
+	$(LOG4CPP_LIBS)					\
+	$(CELT051_LIBS)					\
+	$(SSL_LIBS)					\
+	$(SPICEC_STATIC_LINKAGE_BDYNAMIC)
+
+spicec_LDADD =						\
+	$(QCAIRO_LIBS)					\
+	$(FFMPEG_LIBS)					\
+	$(ALSA_LIBS)					\
+	$(GL_LIBS)					\
+	$(XRANDR_LIBS)					\
+	-lrt
+
diff --git a/client/x11/atomic_count.h b/client/x11/atomic_count.h
new file mode 100644
index 00000000..ca01e14a
--- /dev/null
+++ b/client/x11/atomic_count.h
@@ -0,0 +1,42 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_ATOMIC_COUNT
+#define _H_ATOMIC_COUNT
+
+class AtomicCount {
+public:
+    AtomicCount(uint32_t count = 0) : _count (count) {}
+
+    uint32_t operator ++ ()
+    {
+        return __sync_add_and_fetch(&_count, 1);
+    }
+
+    uint32_t operator -- ()
+    {
+        return __sync_sub_and_fetch(&_count, 1);
+    }
+
+    operator uint32_t () { return _count;}
+
+private:
+    uint32_t _count;
+};
+
+#endif
+
diff --git a/client/x11/events_loop_p.cpp b/client/x11/events_loop_p.cpp
new file mode 100644
index 00000000..4db1469c
--- /dev/null
+++ b/client/x11/events_loop_p.cpp
@@ -0,0 +1,337 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <sys/epoll.h>
+#include <sys/fcntl.h>
+
+#include "events_loop.h"
+#include "debug.h"
+#include "utils.h"
+
+#ifdef USING_EVENT_FD
+#include <sys/eventfd.h>
+#endif
+
+#define NUM_EPOLL_EVENTS 10
+
+#ifdef USING_EVENT_FD
+#define WRITE_FD _event_fd
+#define EVENT_DATA_TYPE eventfd_t
+#else
+#define WRITE_FD _event_write_fd
+#define EVENT_DATA_TYPE uint8_t
+#endif
+
+class EventWrapper {
+public:
+    EventWrapper(EventsLoop& owner, EventSource& event)
+        : _owner (owner)
+        , _event (&event)
+        , _refs (1)
+    {
+    }
+
+    EventWrapper* ref()
+    {
+        _refs++;
+        return this;
+    }
+
+    void unref()
+    {
+        if (!--_refs) {
+            _owner.remove_wrapper(this);
+            delete this;
+        }
+    }
+
+    EventSource* get_event()
+    {
+        return _event;
+    }
+
+    void invalidate()
+    {
+        _event = NULL;
+    }
+
+private:
+    EventsLoop& _owner;
+    EventSource* _event;
+    int _refs;
+};
+
+EventsLoop::EventsLoop()
+{
+    _epoll = epoll_create(NUM_EPOLL_EVENTS);
+    if (_epoll == -1) {
+        THROW("create epool failed");
+    }
+}
+
+EventsLoop::~EventsLoop()
+{
+    Events::iterator iter = _events.begin();
+    for (; iter != _events.end(); iter++) {
+        delete *iter;
+    }
+    close(_epoll);
+}
+
+void EventsLoop::run()
+{
+    for (;;) {
+        run_once();
+    }
+}
+
+void EventsLoop::run_once(int timeout_milli)
+{
+    struct epoll_event events[NUM_EPOLL_EVENTS];
+
+    int num_events = epoll_wait(_epoll, events, NUM_EPOLL_EVENTS, timeout_milli);
+    if (num_events == -1) {
+        if (errno == EINTR) {
+            return;
+        }
+        THROW("wait error eventfd failed");
+    }
+
+    for (int i = 0; i < num_events; i++) {
+        ((EventWrapper*)events[i].data.ptr)->ref();
+    }
+    for (int i = 0; i < num_events; i++) {
+        EventWrapper* wrapper;
+        EventSource* event;
+
+        wrapper = (EventWrapper *)events[i].data.ptr;
+        if ((event = wrapper->get_event())) {
+            event->action();
+        }
+        wrapper->unref();
+    }
+}
+
+void EventsLoop::add_trigger(Trigger& trigger)
+{
+    int fd = trigger.get_fd();
+    EventWrapper* wrapper = new EventWrapper(*this, trigger);
+    struct epoll_event event;
+    event.data.ptr = wrapper;
+    event.events = EPOLLIN;
+    if (epoll_ctl(_epoll, EPOLL_CTL_ADD, fd, &event) == -1) {
+        THROW("epoll add failed");
+    }
+    _events.push_back(wrapper);
+}
+
+void EventsLoop_p::remove_wrapper(EventWrapper* wrapper)
+{
+    Events::iterator iter = _events.begin();
+    for (;; iter++) {
+        if (iter == _events.end()) {
+            THROW("wrapper not found");
+        }
+        if ((*iter) == wrapper) {
+            _events.erase(iter);
+            return;
+        }
+    }
+}
+
+void EventsLoop::remove_trigger(Trigger& trigger)
+{
+    Events::iterator iter = _events.begin();
+    for (;; iter++) {
+        if (iter == _events.end()) {
+            THROW("trigger not found");
+        }
+        if ((*iter)->get_event() == &trigger) {
+            (*iter)->invalidate();
+            (*iter)->unref();
+            break;
+        }
+    }
+    int fd = trigger.get_fd();
+    if (epoll_ctl(_epoll, EPOLL_CTL_DEL, fd, NULL) == -1) {
+        THROW("epoll remove failed");
+    }
+}
+
+EventsLoop::Trigger::Trigger()
+{
+#ifdef USING_EVENT_FD
+    _event_fd = eventfd(0, 0);
+    if (_event_fd == -1) {
+        THROW("create eventfd failed");
+    }
+#else
+    int fd[2];
+    if (pipe(fd) == -1) {
+        THROW("create pipe failed");
+    }
+    _event_fd = fd[0];
+    _event_write_fd = fd[1];
+#endif
+    int flags;
+    if ((flags = fcntl(_event_fd, F_GETFL)) == -1) {
+        THROW("failed to set eventfd non block: %s", strerror(errno));
+    }
+
+    if (fcntl(_event_fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+        THROW("failed to set eventfd non block: %s", strerror(errno));
+    }
+}
+
+EventsLoop::Trigger::~Trigger()
+{
+    close(_event_fd);
+#ifndef USING_EVENT_FD
+    close(_event_write_fd);
+#endif
+}
+
+void EventsLoop::Trigger::trigger()
+{
+    Lock lock(_lock);
+    if (_pending_int) {
+        return;
+    }
+    _pending_int = true;
+    static const EVENT_DATA_TYPE val = 1;
+    if (::write(WRITE_FD, &val, sizeof(val)) != sizeof(val)) {
+        THROW("write event failed");
+    }
+}
+
+bool Trigger_p::reset_event()
+{
+    Lock lock(_lock);
+    if (!_pending_int) {
+        return false;
+    }
+    EVENT_DATA_TYPE val;
+    if (read(_event_fd, &val, sizeof(val)) != sizeof(val)) {
+        THROW("event read error");
+    }
+    _pending_int = false;
+    return true;
+}
+
+void EventsLoop::Trigger::reset()
+{
+    reset_event();
+}
+
+void EventsLoop::Trigger::action()
+{
+    if (reset_event()) {
+        on_event();
+    }
+}
+
+static void set_non_blocking(int fd)
+{
+    int flags;
+    if ((flags = fcntl(fd, F_GETFL)) == -1) {
+        THROW("failed to set socket non block: %s", strerror(errno));
+    }
+
+    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+        THROW("failed to set socket non block: %s", strerror(errno));
+    }
+}
+
+static void set_blocking(int fd)
+{
+    int flags;
+    if ((flags = fcntl(fd, F_GETFL)) == -1) {
+        THROW("failed to clear socket non block: %s", strerror(errno));
+    }
+
+    if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1) {
+        THROW("failed to clear socket non block: %s", strerror(errno));
+    }
+}
+
+static void add_to_poll(int fd, int epoll, EventWrapper* wrapper)
+{
+    struct epoll_event event;
+    event.data.ptr = wrapper;
+    event.events = EPOLLIN | EPOLLOUT | EPOLLET;
+    if (epoll_ctl(epoll, EPOLL_CTL_ADD, fd, &event) == -1) {
+        THROW("epoll add failed");
+    }
+}
+
+void EventsLoop::add_socket(Socket& socket)
+{
+    int fd = socket.get_socket();
+    set_non_blocking(fd);
+    EventWrapper* wrapper = new EventWrapper(*this, socket);
+    add_to_poll(fd, _epoll, wrapper);
+    _events.push_back(wrapper);
+}
+
+static bool remove_event(EventsLoop_p::Events& events, EventSource& event)
+{
+    EventsLoop_p::Events::iterator iter = events.begin();
+    for (;; iter++) {
+        if (iter == events.end()) {
+            return false;
+        }
+        if ((*iter)->get_event() == &event) {
+            (*iter)->invalidate();
+            (*iter)->unref();
+            return true;
+        }
+    }
+}
+
+void EventsLoop::remove_socket(Socket& socket)
+{
+    if (!remove_event(_events, socket)) {
+        THROW("socket not found");
+    }
+    int fd = socket.get_socket();
+    if (epoll_ctl(_epoll, EPOLL_CTL_DEL, fd, NULL) == -1) {
+        THROW("epoll remove failed");
+    }
+    set_blocking(fd);
+}
+
+void EventsLoop::add_file(File& file)
+{
+    int fd = file.get_fd();
+    set_non_blocking(fd);
+    EventWrapper* wrapper = new EventWrapper(*this, file);
+    add_to_poll(fd, _epoll, wrapper);
+    _events.push_back(wrapper);
+}
+
+void EventsLoop::remove_file(File& file)
+{
+    if (!remove_event(_events, file)) {
+        THROW("file not found");
+    }
+    int fd = file.get_fd();
+    if (epoll_ctl(_epoll, EPOLL_CTL_DEL, fd, NULL) == -1) {
+        THROW("epoll remove failed");
+    }
+    set_blocking(fd);
+}
+
diff --git a/client/x11/events_loop_p.h b/client/x11/events_loop_p.h
new file mode 100644
index 00000000..0a70d3ed
--- /dev/null
+++ b/client/x11/events_loop_p.h
@@ -0,0 +1,60 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_EVENTS_LOOP_P
+#define _H_EVENTS_LOOP_P
+
+#include "common.h"
+#include "threads.h"
+
+#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
+#define USING_EVENT_FD
+#endif
+
+#define INFINITE -1
+
+class EventWrapper;
+
+class EventsLoop_p {
+public:
+    void remove_wrapper(EventWrapper*);
+
+public:
+    int _epoll;
+    typedef std::list<EventWrapper*> Events;
+    Events _events;
+
+    friend class EventWrapper;
+};
+
+class Trigger_p {
+public:
+    Trigger_p() : _pending_int (false) {}
+    int get_fd() { return _event_fd;}
+    bool reset_event();
+
+public:
+    int _event_fd;
+#ifndef USING_EVENT_FD
+    int _event_write_fd;
+#endif
+    bool _pending_int;
+    Mutex _lock;
+};
+
+#endif
+
diff --git a/client/x11/images/Makefile.am b/client/x11/images/Makefile.am
new file mode 100644
index 00000000..2e5725ae
--- /dev/null
+++ b/client/x11/images/Makefile.am
@@ -0,0 +1,5 @@
+EXTRA_DIST = \
+        info_image.c                                    \
+        red_icon.c                                      \
+        splash_image.c                                  \
+        $(NULL)
diff --git a/client/x11/images/info_image.c b/client/x11/images/info_image.c
new file mode 100644
index 00000000..4750b13a
--- /dev/null
+++ b/client/x11/images/info_image.c
@@ -0,0 +1,1244 @@
+static const struct {
+	uint32_t width;
+	uint32_t height;
+	uint8_t pixel_data[29700];
+} _info_image = { 275, 27, {
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x12,0x12,0x12,0x16,0x4a,0x4a,0x4a,0x53,
+		0x5e,0x5e,0x5e,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x5e,0x5e,0x5e,0x69,0x4a,0x4a,0x4a,0x53,
+		0x12,0x12,0x12,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x10,0x16,0x4a,0x4a,0x4a,0x53,0x5e,0x5e,0x5e,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x28,0x28,0x28,0x69,0x2a,0x2a,0x2a,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x29,0x29,0x29,0x69,
+		0x28,0x28,0x28,0x69,0x23,0x23,0x24,0x69,0x27,0x27,0x27,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x5e,0x5e,0x5e,0x69,0x4a,0x4a,0x4a,0x53,0x10,0x10,0x10,0x16,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x10,0x10,0x16,0x4a,0x4a,0x4a,0x53,0x5e,0x5e,0x5e,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x29,0x29,0x29,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x16,0x16,0x25,0x69,0x0e,0x0f,0x4d,0x69,0x0b,0x0c,0x49,0x69,0x0a,0x0b,0x41,0x69,0x0a,0x0b,0x43,0x69,
+		0x07,0x07,0x2d,0x69,0x12,0x12,0x2b,0x69,0x1f,0x1f,0x23,0x69,0x2a,0x2a,0x2a,0x69,0x29,0x29,0x29,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x2a,0x2a,0x2a,0x69,0x2a,0x2a,0x2a,0x69,0x5e,0x5e,0x5e,0x69,0x4a,0x4a,0x4a,0x53,0x10,0x10,0x10,0x16,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,0x5e,0x5e,0x5e,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x28,0x28,0x28,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x25,0x25,0x26,0x69,
+		0x0f,0x0f,0x3c,0x69,0x0a,0x0b,0x42,0x69,0x0b,0x0c,0x4a,0x69,0x0c,0x0d,0x4d,0x69,0x0d,0x0e,0x53,0x69,0x0a,0x0a,0x3f,0x69,
+		0x0b,0x0c,0x46,0x69,0x10,0x10,0x33,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x28,0x28,0x28,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x5e,0x5e,0x5e,0x69,0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,0x5e,0x5e,0x5e,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x1e,0x1e,0x22,0x69,0x0b,0x0b,0x45,0x69,
+		0x02,0x03,0x12,0x69,0x05,0x05,0x23,0x69,0x09,0x0a,0x3d,0x69,0x0d,0x0e,0x51,0x69,0x0d,0x0e,0x51,0x69,0x0d,0x0e,0x52,0x69,
+		0x0e,0x0f,0x4a,0x69,0x22,0x22,0x23,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x60,0x60,0x60,0x69,
+		0x46,0x46,0x46,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,0x29,0x29,0x29,0x69,
+		0x5e,0x5e,0x5e,0x69,0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,
+		0x4a,0x4a,0x4a,0x53,0x5e,0x5e,0x5e,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x27,0x27,0x27,0x69,
+		0x26,0x26,0x26,0x69,0x19,0x19,0x21,0x69,0x15,0x15,0x25,0x69,0x19,0x19,0x21,0x69,0x0b,0x0c,0x4a,0x69,0x0d,0x0e,0x54,0x69,
+		0x0d,0x0e,0x54,0x69,0x0d,0x0e,0x51,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0d,0x0e,0x54,0x69,
+		0x13,0x14,0x27,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x35,0x35,0x35,0x69,0x5c,0x5c,0x5c,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x39,0x39,0x39,0x69,
+		0x57,0x57,0x57,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x31,0x31,0x31,0x69,0x5c,0x5c,0x5c,0x69,0x31,0x31,0x31,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x4a,0x4a,0x4a,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x2c,0x2c,0x2c,0x69,0x69,0x69,0x69,0x69,
+		0x53,0x53,0x53,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x31,0x31,0x31,0x69,0x5c,0x5c,0x5c,0x69,0x31,0x31,0x31,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x35,0x35,0x35,0x69,0x5c,0x5c,0x5c,0x69,0x28,0x28,0x28,0x69,0x4a,0x4a,0x4a,0x69,0x69,0x69,0x69,0x69,
+		0x35,0x35,0x35,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x46,0x46,0x46,0x69,0x4f,0x4f,0x4f,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x4a,0x4a,0x4a,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x60,0x60,0x60,0x69,0x46,0x46,0x46,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,
+		0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x28,0x28,0x28,0x69,0x5e,0x5e,0x5e,0x69,
+		0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,
+		0x5d,0x5d,0x5d,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x10,0x10,0x31,0x69,
+		0x0e,0x0e,0x56,0x69,0x0e,0x0f,0x58,0x69,0x05,0x05,0x23,0x69,0x00,0x00,0x05,0x69,0x13,0x13,0x27,0x69,0x0f,0x0f,0x3b,0x69,
+		0x0e,0x0f,0x4c,0x69,0x0c,0x0d,0x50,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0d,0x0e,0x54,0x69,0x10,0x10,0x30,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x53,0x53,0x53,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x69,0x69,0x69,0x69,0x46,0x46,0x46,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x60,0x60,0x60,0x69,0x4f,0x4f,0x4f,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x4f,0x4f,0x4f,0x69,0x60,0x60,0x60,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x57,0x57,0x57,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x30,0x30,0x30,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x46,0x46,0x46,0x69,0x69,0x69,0x69,0x69,0x39,0x39,0x39,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x64,0x64,0x64,0x69,0x53,0x53,0x53,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x30,0x30,0x30,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x60,0x60,0x60,0x69,0x4f,0x4f,0x4f,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x60,0x60,0x60,0x69,0x46,0x46,0x46,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x46,0x46,0x46,0x69,0x60,0x60,0x60,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x46,0x46,0x46,0x69,0x27,0x27,0x27,0x69,0x46,0x46,0x46,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x46,0x46,0x46,0x69,
+		0x27,0x27,0x27,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3d,0x3d,0x3d,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x46,0x46,0x46,0x69,0x64,0x64,0x64,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x53,0x53,0x53,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x53,0x53,0x53,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x5d,0x5d,0x5d,0x69,0x4a,0x4a,0x4a,0x53,
+		0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,0x5d,0x5d,0x5d,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x12,0x12,0x29,0x69,0x0d,0x0e,0x55,0x69,
+		0x0d,0x0e,0x51,0x69,0x0b,0x0c,0x4c,0x69,0x06,0x06,0x25,0x69,0x25,0x25,0x25,0x69,0x27,0x27,0x27,0x69,0x1e,0x1e,0x20,0x69,
+		0x0b,0x0c,0x49,0x69,0x0d,0x0e,0x50,0x69,0x0c,0x0d,0x4f,0x69,0x0d,0x0e,0x52,0x69,0x0f,0x10,0x33,0x69,0x10,0x10,0x32,0x69,
+		0x17,0x17,0x21,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x69,0x69,0x69,0x69,
+		0x41,0x41,0x41,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x38,0x38,0x38,0x69,0x69,0x69,0x69,0x69,0x46,0x46,0x46,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x41,0x41,0x41,0x69,
+		0x69,0x69,0x69,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x69,0x69,0x69,0x69,0x46,0x46,0x46,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x60,0x60,0x60,0x69,
+		0x4e,0x4e,0x4e,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x4e,0x4e,0x4e,0x69,0x60,0x60,0x60,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x57,0x57,0x57,0x69,
+		0x57,0x57,0x57,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x2f,0x2f,0x2f,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x2b,0x2b,0x2b,0x69,0x64,0x64,0x64,0x69,0x4a,0x4a,0x4a,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x3c,0x3c,0x3c,0x69,
+		0x69,0x69,0x69,0x69,0x38,0x38,0x38,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x41,0x41,0x41,0x69,
+		0x69,0x69,0x69,0x69,0x2f,0x2f,0x2f,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x41,0x41,0x41,0x69,
+		0x69,0x69,0x69,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x60,0x60,0x60,0x69,0x4e,0x4e,0x4e,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x60,0x60,0x60,0x69,0x46,0x46,0x46,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x3c,0x3c,0x3c,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x2b,0x2b,0x2b,0x69,0x46,0x46,0x46,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x41,0x41,0x41,0x69,
+		0x34,0x34,0x34,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x27,0x27,0x27,0x69,0x4e,0x4e,0x4e,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x53,0x53,0x53,0x69,
+		0x27,0x27,0x27,0x69,0x53,0x53,0x53,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,
+		0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x27,0x27,0x27,0x69,0x5d,0x5d,0x5d,0x69,0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,0x5d,0x5d,0x5d,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x25,0x25,0x25,0x69,0x10,0x11,0x2c,0x69,0x0e,0x0f,0x52,0x69,
+		0x0d,0x0e,0x51,0x69,0x0d,0x0e,0x54,0x69,0x0e,0x0e,0x45,0x69,0x11,0x11,0x2a,0x69,0x1c,0x1c,0x20,0x69,0x08,0x09,0x36,0x69,
+		0x0d,0x0e,0x52,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4e,0x69,0x0d,0x0e,0x53,0x69,0x0e,0x0f,0x52,0x69,
+		0x17,0x17,0x20,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x69,0x69,0x69,0x69,0x41,0x41,0x41,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x60,0x60,0x60,0x69,0x4a,0x4a,0x4a,0x69,0x26,0x26,0x26,0x69,
+		0x38,0x38,0x38,0x69,0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x69,0x69,0x69,0x69,
+		0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x60,0x60,0x60,0x69,0x4e,0x4e,0x4e,0x69,
+		0x26,0x26,0x26,0x69,0x33,0x33,0x33,0x69,0x64,0x64,0x64,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x52,0x52,0x52,0x69,
+		0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x41,0x41,0x41,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x57,0x57,0x57,0x69,0x57,0x57,0x57,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,
+		0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x33,0x33,0x33,0x69,0x38,0x38,0x38,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4e,0x4e,0x4e,0x69,0x26,0x26,0x26,0x69,0x38,0x38,0x38,0x69,
+		0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,0x38,0x38,0x38,0x69,
+		0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x52,0x52,0x52,0x69,0x38,0x38,0x38,0x69,0x69,0x69,0x69,0x69,
+		0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x41,0x41,0x41,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,
+		0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,
+		0x2f,0x2f,0x2f,0x69,0x2b,0x2b,0x2b,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,
+		0x2f,0x2f,0x2f,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,
+		0x38,0x38,0x38,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x4e,0x4e,0x4e,0x69,0x64,0x64,0x64,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x4e,0x4e,0x4e,0x69,0x64,0x64,0x64,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x60,0x60,0x60,0x69,0x4e,0x4e,0x4e,0x69,0x26,0x26,0x26,0x69,0x69,0x69,0x69,0x69,
+		0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x38,0x38,0x38,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x4e,0x4e,0x4e,0x69,0x26,0x26,0x26,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,
+		0x38,0x38,0x38,0x69,0x69,0x69,0x69,0x69,0x38,0x38,0x38,0x69,0x26,0x26,0x26,0x69,0x4e,0x4e,0x4e,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x38,0x38,0x38,0x69,0x26,0x26,0x26,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,
+		0x26,0x26,0x26,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x2f,0x2f,0x2f,0x69,0x2f,0x2f,0x2f,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4e,0x4e,0x4e,0x69,0x26,0x26,0x26,0x69,0x41,0x41,0x41,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,0x57,0x57,0x57,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x2f,0x2f,0x2f,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,
+		0x2f,0x2f,0x2f,0x69,0x26,0x26,0x26,0x69,0x41,0x41,0x41,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,
+		0x38,0x38,0x38,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x60,0x60,0x60,0x69,0x69,0x69,0x69,0x69,
+		0x60,0x60,0x60,0x69,0x33,0x33,0x33,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x60,0x60,0x60,0x69,0x45,0x45,0x45,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x4a,0x4a,0x4a,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x4a,0x4a,0x4a,0x69,0x3c,0x3c,0x3c,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,
+		0x26,0x26,0x26,0x69,0x2b,0x2b,0x2b,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4a,0x4a,0x4a,0x69,0x33,0x33,0x33,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x2f,0x2f,0x2f,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x4e,0x4e,0x4e,0x69,0x26,0x26,0x26,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x52,0x52,0x52,0x69,0x26,0x26,0x26,0x69,
+		0x52,0x52,0x52,0x69,0x69,0x69,0x69,0x69,0x52,0x52,0x52,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,
+		0x26,0x26,0x26,0x69,0x26,0x26,0x26,0x69,0x5d,0x5d,0x5d,0x69,0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x4a,0x4a,0x4a,0x53,0x5d,0x5d,0x5d,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x12,0x12,0x25,0x69,0x0c,0x0d,0x4e,0x69,
+		0x0d,0x0e,0x54,0x69,0x0d,0x0e,0x51,0x69,0x0d,0x0e,0x54,0x69,0x0d,0x0e,0x50,0x69,0x0c,0x0d,0x4d,0x69,0x0c,0x0d,0x4f,0x69,
+		0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,0x0e,0x0e,0x56,0x69,0x12,0x13,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,0x2a,0x2a,0x2a,0x69,0x64,0x64,0x64,0x69,
+		0x45,0x45,0x45,0x69,0x25,0x25,0x25,0x69,0x3c,0x3c,0x3c,0x69,0x69,0x69,0x69,0x69,0x33,0x33,0x33,0x69,0x37,0x37,0x37,0x69,
+		0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x25,0x25,0x25,0x69,0x57,0x57,0x57,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4e,0x4e,0x4e,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x3c,0x3c,0x3c,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,
+		0x25,0x25,0x25,0x69,0x4e,0x4e,0x4e,0x69,0x5f,0x5f,0x5f,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x57,0x57,0x57,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,
+		0x3c,0x3c,0x3c,0x69,0x2a,0x2a,0x2a,0x69,0x5f,0x5f,0x5f,0x69,0x52,0x52,0x52,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,
+		0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x2a,0x2a,0x2a,0x69,0x64,0x64,0x64,0x69,0x45,0x45,0x45,0x69,
+		0x25,0x25,0x25,0x69,0x3c,0x3c,0x3c,0x69,0x69,0x69,0x69,0x69,0x33,0x33,0x33,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,
+		0x49,0x49,0x49,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x4e,0x4e,0x4e,0x69,
+		0x25,0x25,0x25,0x69,0x49,0x49,0x49,0x69,0x69,0x69,0x69,0x69,0x2a,0x2a,0x2a,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,
+		0x3c,0x3c,0x3c,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,
+		0x3c,0x3c,0x3c,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x2a,0x2a,0x2a,0x69,0x45,0x45,0x45,0x69,0x25,0x25,0x25,0x69,
+		0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x33,0x33,0x33,0x69,0x25,0x25,0x25,0x69,0x49,0x49,0x49,0x69,0x64,0x64,0x64,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x3c,0x3c,0x3c,0x69,
+		0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x25,0x25,0x25,0x69,0x64,0x64,0x64,0x69,0x49,0x49,0x49,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x5f,0x5f,0x5f,0x69,0x4e,0x4e,0x4e,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,
+		0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x2a,0x2a,0x2a,0x69,0x25,0x25,0x25,0x69,
+		0x57,0x57,0x57,0x69,0x5b,0x5b,0x5b,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,
+		0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x25,0x25,0x25,0x69,0x2e,0x2e,0x2e,0x69,0x33,0x33,0x33,0x69,
+		0x25,0x25,0x25,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x2a,0x2a,0x2a,0x69,0x25,0x25,0x25,0x69,0x5f,0x5f,0x5f,0x69,
+		0x4e,0x4e,0x4e,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,
+		0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x45,0x45,0x45,0x69,0x25,0x25,0x25,0x69,0x52,0x52,0x52,0x69,0x64,0x64,0x64,0x69,
+		0x2a,0x2a,0x2a,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x2a,0x2a,0x2a,0x69,0x5f,0x5f,0x5f,0x69,
+		0x52,0x52,0x52,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x5f,0x5f,0x5f,0x69,0x45,0x45,0x45,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x49,0x49,0x49,0x69,
+		0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x45,0x45,0x45,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x33,0x33,0x33,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,0x3c,0x3c,0x3c,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3c,0x3c,0x3c,0x69,
+		0x25,0x25,0x25,0x69,0x2a,0x2a,0x2a,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x52,0x52,0x52,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x33,0x33,0x33,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x5d,0x5d,0x5d,0x69,0x4a,0x4a,0x4a,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x0f,0x0f,0x0f,0x16,0x49,0x49,0x49,0x53,0x5d,0x5d,0x5d,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x2b,0x2b,0x2b,0x69,0x2c,0x2c,0x34,0x69,0x09,0x09,0x38,0x69,
+		0x0c,0x0d,0x4f,0x69,0x0d,0x0e,0x54,0x69,0x0d,0x0e,0x52,0x69,0x0d,0x0e,0x51,0x69,0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x4f,0x69,
+		0x0c,0x0d,0x4f,0x69,0x0c,0x0d,0x50,0x69,0x0d,0x0e,0x54,0x69,0x0d,0x0e,0x46,0x69,0x1e,0x1e,0x20,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x5f,0x5f,0x5f,0x69,0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,
+		0x64,0x64,0x64,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,0x25,0x25,0x25,0x69,
+		0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x56,0x56,0x56,0x69,0x56,0x56,0x56,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,
+		0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x25,0x25,0x25,0x69,
+		0x32,0x32,0x32,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x2e,0x2e,0x2e,0x69,
+		0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x4d,0x4d,0x4d,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x44,0x44,0x44,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x64,0x64,0x64,0x69,
+		0x4d,0x4d,0x4d,0x69,0x3b,0x3b,0x3b,0x69,0x69,0x69,0x69,0x69,0x32,0x32,0x32,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,
+		0x37,0x37,0x37,0x69,0x29,0x29,0x29,0x69,0x56,0x56,0x56,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x5f,0x5f,0x5f,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,
+		0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x37,0x37,0x37,0x69,0x69,0x69,0x69,0x69,
+		0x40,0x40,0x40,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x49,0x49,0x49,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x25,0x25,0x25,0x69,0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x40,0x40,0x40,0x69,0x69,0x69,0x69,0x69,0x2e,0x2e,0x2e,0x69,0x44,0x44,0x44,0x69,
+		0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x32,0x32,0x32,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,
+		0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x5f,0x5f,0x5f,0x69,
+		0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x32,0x32,0x32,0x69,0x49,0x49,0x49,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,
+		0x29,0x29,0x29,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x64,0x64,0x64,0x69,0x44,0x44,0x44,0x69,0x25,0x25,0x25,0x69,0x32,0x32,0x32,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x3b,0x3b,0x3b,0x69,0x3b,0x3b,0x3b,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x52,0x52,0x52,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x32,0x32,0x32,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,0x25,0x25,0x25,0x69,
+		0x5d,0x5d,0x5d,0x69,0x49,0x49,0x49,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,
+		0x49,0x49,0x49,0x53,0x5d,0x5d,0x5d,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x22,0x22,0x22,0x69,0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x3a,0x3a,0x3a,0x69,0x14,0x15,0x20,0x69,
+		0x07,0x07,0x2c,0x69,0x0a,0x0b,0x41,0x69,0x0c,0x0d,0x4c,0x69,0x0d,0x0e,0x51,0x69,0x0d,0x0e,0x52,0x69,0x0d,0x0e,0x53,0x69,
+		0x0e,0x0e,0x4c,0x69,0x0e,0x0f,0x37,0x69,0x1b,0x1b,0x1e,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x24,0x24,0x24,0x69,0x4d,0x4d,0x4d,0x69,0x69,0x69,0x69,0x69,
+		0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x36,0x36,0x36,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x28,0x28,0x28,0x69,
+		0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,0x24,0x24,0x24,0x69,0x64,0x64,0x64,0x69,0x48,0x48,0x48,0x69,
+		0x24,0x24,0x24,0x69,0x2d,0x2d,0x2d,0x69,0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x24,0x24,0x24,0x69,0x4d,0x4d,0x4d,0x69,
+		0x5f,0x5f,0x5f,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x56,0x56,0x56,0x69,0x56,0x56,0x56,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2d,0x2d,0x2d,0x69,
+		0x24,0x24,0x24,0x69,0x36,0x36,0x36,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x36,0x36,0x36,0x69,0x69,0x69,0x69,0x69,0x36,0x36,0x36,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x36,0x36,0x36,0x69,0x69,0x69,0x69,0x69,0x36,0x36,0x36,0x69,0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,
+		0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x44,0x44,0x44,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x31,0x31,0x31,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,
+		0x28,0x28,0x28,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x48,0x48,0x48,0x69,0x64,0x64,0x64,0x69,
+		0x4d,0x4d,0x4d,0x69,0x5b,0x5b,0x5b,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x5f,0x5f,0x5f,0x69,
+		0x4d,0x4d,0x4d,0x69,0x24,0x24,0x24,0x69,0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x24,0x24,0x24,0x69,0x36,0x36,0x36,0x69,0x69,0x69,0x69,0x69,0x36,0x36,0x36,0x69,
+		0x44,0x44,0x44,0x69,0x64,0x64,0x64,0x69,0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,
+		0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,
+		0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,0x64,0x64,0x64,0x69,0x48,0x48,0x48,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,
+		0x69,0x69,0x69,0x69,0x2d,0x2d,0x2d,0x69,0x24,0x24,0x24,0x69,0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2d,0x2d,0x2d,0x69,0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,0x44,0x44,0x44,0x69,
+		0x69,0x69,0x69,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x5f,0x5f,0x5f,0x69,0x44,0x44,0x44,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x4d,0x4d,0x4d,0x69,
+		0x3f,0x3f,0x3f,0x69,0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,
+		0x44,0x44,0x44,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3b,0x3b,0x3b,0x69,
+		0x2d,0x2d,0x2d,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x51,0x51,0x51,0x69,0x24,0x24,0x24,0x69,0x44,0x44,0x44,0x69,
+		0x69,0x69,0x69,0x69,0x44,0x44,0x44,0x69,0x24,0x24,0x24,0x69,0x51,0x51,0x51,0x69,0x69,0x69,0x69,0x69,0x51,0x51,0x51,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,
+		0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x24,0x24,0x24,0x69,0x5d,0x5d,0x5d,0x69,
+		0x49,0x49,0x49,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x49,0x49,0x49,0x53,
+		0x5d,0x5d,0x5d,0x69,0x26,0x26,0x26,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x2a,0x2a,0x2a,0x69,0x58,0x58,0x58,0x69,
+		0x4d,0x4d,0x4d,0x69,0x1e,0x1e,0x1e,0x69,0x56,0x56,0x56,0x69,0x69,0x69,0x69,0x69,0x5d,0x5d,0x5d,0x69,0x1a,0x1a,0x1a,0x69,
+		0x0e,0x0e,0x0e,0x69,0x14,0x14,0x1a,0x69,0x0f,0x10,0x1c,0x69,0x11,0x11,0x23,0x69,0x17,0x18,0x21,0x69,0x1b,0x1b,0x1d,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x23,0x23,0x23,0x69,0x2c,0x2c,0x2c,0x69,0x69,0x69,0x69,0x69,0x4d,0x4d,0x4d,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x64,0x64,0x64,0x69,0x56,0x56,0x56,0x69,0x23,0x23,0x23,0x69,0x35,0x35,0x35,0x69,
+		0x31,0x31,0x31,0x69,0x23,0x23,0x23,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,
+		0x56,0x56,0x56,0x69,0x69,0x69,0x69,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,0x23,0x23,0x23,0x69,0x64,0x64,0x64,0x69,0x4d,0x4d,0x4d,0x69,0x23,0x23,0x23,0x69,
+		0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x23,0x23,0x23,0x69,0x4d,0x4d,0x4d,0x69,0x64,0x64,0x64,0x69,
+		0x23,0x23,0x23,0x69,0x31,0x31,0x31,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x56,0x56,0x56,0x69,0x56,0x56,0x56,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x4d,0x4d,0x4d,0x69,
+		0x5f,0x5f,0x5f,0x69,0x23,0x23,0x23,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x31,0x31,0x31,0x69,0x31,0x31,0x31,0x69,
+		0x23,0x23,0x23,0x69,0x64,0x64,0x64,0x69,0x56,0x56,0x56,0x69,0x23,0x23,0x23,0x69,0x35,0x35,0x35,0x69,0x31,0x31,0x31,0x69,
+		0x23,0x23,0x23,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x4d,0x4d,0x4d,0x69,0x23,0x23,0x23,0x69,0x48,0x48,0x48,0x69,0x69,0x69,0x69,0x69,
+		0x27,0x27,0x27,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2c,0x2c,0x2c,0x69,0x2c,0x2c,0x2c,0x69,0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,
+		0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,
+		0x23,0x23,0x23,0x69,0x43,0x43,0x43,0x69,0x27,0x27,0x27,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x5f,0x5f,0x5f,0x69,0x4d,0x4d,0x4d,0x69,
+		0x23,0x23,0x23,0x69,0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x31,0x31,0x31,0x69,0x31,0x31,0x31,0x69,0x23,0x23,0x23,0x69,0x5f,0x5f,0x5f,0x69,
+		0x56,0x56,0x56,0x69,0x23,0x23,0x23,0x69,0x48,0x48,0x48,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x43,0x43,0x43,0x69,
+		0x69,0x69,0x69,0x69,0x2c,0x2c,0x2c,0x69,0x2c,0x2c,0x2c,0x69,0x5b,0x5b,0x5b,0x69,0x5f,0x5f,0x5f,0x69,0x23,0x23,0x23,0x69,
+		0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x23,0x23,0x23,0x69,0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2c,0x2c,0x2c,0x69,
+		0x27,0x27,0x27,0x69,0x5f,0x5f,0x5f,0x69,0x51,0x51,0x51,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x3f,0x3f,0x3f,0x69,0x23,0x23,0x23,0x69,0x56,0x56,0x56,0x69,0x69,0x69,0x69,0x69,
+		0x2c,0x2c,0x2c,0x69,0x23,0x23,0x23,0x69,0x5f,0x5f,0x5f,0x69,0x51,0x51,0x51,0x69,0x2c,0x2c,0x2c,0x69,0x27,0x27,0x27,0x69,
+		0x3f,0x3f,0x3f,0x69,0x69,0x69,0x69,0x69,0x2c,0x2c,0x2c,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,
+		0x23,0x23,0x23,0x69,0x51,0x51,0x51,0x69,0x64,0x64,0x64,0x69,0x27,0x27,0x27,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x4d,0x4d,0x4d,0x69,0x5f,0x5f,0x5f,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x5f,0x5f,0x5f,0x69,0x43,0x43,0x43,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x2c,0x2c,0x2c,0x69,0x43,0x43,0x43,0x69,
+		0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x31,0x31,0x31,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3a,0x3a,0x3a,0x69,0x23,0x23,0x23,0x69,
+		0x4d,0x4d,0x4d,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x56,0x56,0x56,0x69,0x27,0x27,0x27,0x69,0x51,0x51,0x51,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,
+		0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x23,0x23,0x23,0x69,0x26,0x26,0x26,0x69,0x5d,0x5d,0x5d,0x69,0x49,0x49,0x49,0x53,
+		0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x47,0x47,0x47,0x53,0x5d,0x5d,0x5d,0x69,
+		0x25,0x25,0x25,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x23,0x23,0x23,0x69,0x5e,0x5e,0x5e,0x69,0x69,0x69,0x69,0x69,
+		0x5f,0x5f,0x5f,0x69,0x61,0x61,0x61,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x65,0x65,0x65,0x69,
+		0x5f,0x5f,0x5f,0x69,0x5f,0x5f,0x5f,0x69,0x64,0x64,0x64,0x69,0x4a,0x4a,0x4a,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x69,0x69,0x69,0x69,
+		0x3e,0x3e,0x3e,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,
+		0x22,0x22,0x22,0x69,0x35,0x35,0x35,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x48,0x48,0x48,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x4c,0x4c,0x4c,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,
+		0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x5f,0x5f,0x5f,0x69,
+		0x4c,0x4c,0x4c,0x69,0x22,0x22,0x22,0x69,0x3e,0x3e,0x3e,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,
+		0x69,0x69,0x69,0x69,0x3e,0x3e,0x3e,0x69,0x22,0x22,0x22,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x39,0x39,0x39,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x56,0x56,0x56,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,
+		0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x4c,0x4c,0x4c,0x69,0x5f,0x5f,0x5f,0x69,
+		0x22,0x22,0x22,0x69,0x2b,0x2b,0x2b,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x48,0x48,0x48,0x69,0x22,0x22,0x22,0x69,
+		0x35,0x35,0x35,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x48,0x48,0x48,0x69,0x22,0x22,0x22,0x69,
+		0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x35,0x35,0x35,0x69,
+		0x69,0x69,0x69,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x3e,0x3e,0x3e,0x69,0x22,0x22,0x22,0x69,
+		0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x3e,0x3e,0x3e,0x69,
+		0x69,0x69,0x69,0x69,0x2b,0x2b,0x2b,0x69,0x3e,0x3e,0x3e,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x5b,0x5b,0x5b,0x69,0x26,0x26,0x26,0x69,0x22,0x22,0x22,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x64,0x64,0x64,0x69,0x3e,0x3e,0x3e,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x2b,0x2b,0x2b,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x5f,0x5f,0x5f,0x69,0x4c,0x4c,0x4c,0x69,0x22,0x22,0x22,0x69,
+		0x69,0x69,0x69,0x69,0x43,0x43,0x43,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x2b,0x2b,0x2b,0x69,
+		0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x48,0x48,0x48,0x69,0x22,0x22,0x22,0x69,0x35,0x35,0x35,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x5f,0x5f,0x5f,0x69,0x69,0x69,0x69,0x69,0x35,0x35,0x35,0x69,0x26,0x26,0x26,0x69,0x5b,0x5b,0x5b,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x5f,0x5f,0x5f,0x69,0x22,0x22,0x22,0x69,0x3e,0x3e,0x3e,0x69,
+		0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,0x3e,0x3e,0x3e,0x69,0x69,0x69,0x69,0x69,0x2b,0x2b,0x2b,0x69,0x3e,0x3e,0x3e,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4c,0x4c,0x4c,0x69,0x22,0x22,0x22,0x69,
+		0x4c,0x4c,0x4c,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x69,0x69,0x69,0x69,0x2b,0x2b,0x2b,0x69,
+		0x22,0x22,0x22,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x26,0x26,0x26,0x69,0x3e,0x3e,0x3e,0x69,
+		0x69,0x69,0x69,0x69,0x2b,0x2b,0x2b,0x69,0x22,0x22,0x22,0x69,0x3e,0x3e,0x3e,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x5f,0x5f,0x5f,0x69,0x35,0x35,0x35,0x69,0x22,0x22,0x22,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x4c,0x4c,0x4c,0x69,0x5f,0x5f,0x5f,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x5f,0x5f,0x5f,0x69,0x43,0x43,0x43,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x35,0x35,0x35,0x69,0x48,0x48,0x48,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x5b,0x5b,0x5b,0x69,0x39,0x39,0x39,0x69,0x22,0x22,0x22,0x69,0x43,0x43,0x43,0x69,0x69,0x69,0x69,0x69,
+		0x64,0x64,0x64,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x30,0x30,0x30,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x39,0x39,0x39,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x43,0x43,0x43,0x69,0x64,0x64,0x64,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x4c,0x4c,0x4c,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x51,0x51,0x51,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x64,0x64,0x64,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,
+		0x22,0x22,0x22,0x69,0x22,0x22,0x22,0x69,0x25,0x25,0x25,0x69,0x5d,0x5d,0x5d,0x69,0x47,0x47,0x47,0x53,0x0f,0x0f,0x0f,0x16,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x0f,0x0f,0x16,0x46,0x46,0x46,0x53,0x5d,0x5d,0x5d,0x69,0x2d,0x2d,0x2d,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x34,0x34,0x34,0x69,0x66,0x66,0x66,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x40,0x40,0x40,0x69,
+		0x42,0x42,0x42,0x69,0x69,0x69,0x69,0x69,0x37,0x37,0x37,0x69,0x21,0x21,0x21,0x69,0x1e,0x1e,0x1e,0x69,0x20,0x20,0x20,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x34,0x34,0x34,0x69,0x69,0x69,0x69,0x69,
+		0x34,0x34,0x34,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x5f,0x5f,0x5f,0x69,0x42,0x42,0x42,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,0x21,0x21,0x21,0x69,
+		0x21,0x21,0x21,0x69,0x2d,0x2d,0x2d,0x69,0x5d,0x5d,0x5d,0x69,0x46,0x46,0x46,0x53,0x0f,0x0f,0x0f,0x16,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x10,0x10,0x10,0x16,0x3f,0x3f,0x3f,0x51,0x5c,0x5c,0x5c,0x69,0x38,0x38,0x38,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x3f,0x3f,0x3f,0x69,0x66,0x66,0x66,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,
+		0x5c,0x5c,0x5c,0x69,0x1c,0x1c,0x1c,0x69,0x2d,0x2d,0x2d,0x69,0x4a,0x4a,0x4a,0x69,0x21,0x21,0x21,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x33,0x33,0x33,0x69,0x5a,0x5a,0x5a,0x69,0x2a,0x2a,0x2a,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x5f,0x5f,0x5f,0x69,0x42,0x42,0x42,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,0x20,0x20,0x20,0x69,
+		0x38,0x38,0x38,0x69,0x5c,0x5c,0x5c,0x69,0x3f,0x3f,0x3f,0x51,0x10,0x10,0x10,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x0e,0x0e,0x0e,0x13,0x33,0x33,0x33,0x4a,0x5a,0x5a,0x5a,0x66,0x48,0x48,0x48,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x33,0x33,0x33,0x69,0x5d,0x5d,0x5d,0x69,0x69,0x69,0x69,0x69,
+		0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x69,0x66,0x66,0x66,0x69,0x2e,0x2e,0x2e,0x69,
+		0x48,0x48,0x48,0x69,0x4a,0x4a,0x4a,0x69,0x22,0x22,0x22,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x1f,0x1f,0x1f,0x69,0x48,0x48,0x48,0x69,
+		0x5a,0x5a,0x5a,0x66,0x33,0x33,0x33,0x4a,0x0e,0x0e,0x0e,0x13,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0b,0x0b,0x0b,0x0f,
+		0x27,0x27,0x27,0x3d,0x55,0x55,0x55,0x61,0x5a,0x5a,0x5a,0x69,0x33,0x33,0x33,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1f,0x1f,0x1f,0x69,0x35,0x35,0x35,0x69,0x50,0x50,0x50,0x69,
+		0x62,0x62,0x62,0x69,0x68,0x68,0x68,0x69,0x67,0x67,0x67,0x69,0x5b,0x5b,0x5b,0x69,0x43,0x43,0x43,0x69,0x28,0x28,0x28,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,
+		0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x1e,0x1e,0x1e,0x69,0x33,0x33,0x33,0x69,0x5a,0x5a,0x5a,0x69,0x55,0x55,0x55,0x61,
+		0x27,0x27,0x27,0x3d,0x0b,0x0b,0x0b,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x06,0x06,0x08,0x1f,0x1f,0x1f,0x2c,
+		0x3e,0x3e,0x3e,0x57,0x5b,0x5b,0x5b,0x68,0x4b,0x4b,0x4b,0x69,0x27,0x27,0x27,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,0x1d,0x1d,0x1d,0x69,
+		0x1d,0x1d,0x1d,0x69,0x27,0x27,0x27,0x69,0x4b,0x4b,0x4b,0x69,0x5b,0x5b,0x5b,0x68,0x3e,0x3e,0x3e,0x57,0x1f,0x1f,0x1f,0x2c,
+		0x06,0x06,0x06,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x03,0x11,0x11,0x11,0x16,0x2a,0x2a,0x2a,0x41,
+		0x4b,0x4b,0x4b,0x5f,0x5b,0x5b,0x5b,0x68,0x4a,0x4a,0x4a,0x69,0x31,0x31,0x31,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x31,0x31,0x31,0x69,
+		0x4a,0x4a,0x4a,0x69,0x5b,0x5b,0x5b,0x68,0x4b,0x4b,0x4b,0x5f,0x2a,0x2a,0x2a,0x41,0x11,0x11,0x11,0x16,0x02,0x02,0x02,0x03,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x06,0x06,0x06,0x08,0x1a,0x1a,0x1a,0x22,0x2d,0x2d,0x2d,0x47,
+		0x4a,0x4a,0x4a,0x5f,0x5a,0x5a,0x5a,0x68,0x59,0x59,0x59,0x69,0x46,0x46,0x46,0x69,0x35,0x35,0x35,0x69,0x28,0x28,0x28,0x69,
+		0x1f,0x1f,0x1f,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,0x1c,0x1c,0x1c,0x69,
+		0x1f,0x1f,0x1f,0x69,0x28,0x28,0x28,0x69,0x35,0x35,0x35,0x69,0x46,0x46,0x46,0x69,0x59,0x59,0x59,0x69,0x5a,0x5a,0x5a,0x68,
+		0x4a,0x4a,0x4a,0x5f,0x2d,0x2d,0x2d,0x47,0x1a,0x1a,0x1a,0x22,0x06,0x06,0x06,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x09,0x09,0x09,0x0b,0x1a,0x1a,0x1a,0x22,0x29,0x29,0x29,0x41,
+		0x3d,0x3d,0x3d,0x57,0x54,0x54,0x54,0x61,0x59,0x59,0x59,0x66,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,
+		0x5b,0x5b,0x5b,0x69,0x5b,0x5b,0x5b,0x69,0x59,0x59,0x59,0x66,0x54,0x54,0x54,0x61,0x3d,0x3d,0x3d,0x57,0x29,0x29,0x29,0x41,
+		0x1a,0x1a,0x1a,0x22,0x09,0x09,0x09,0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x06,0x06,0x06,0x08,0x11,0x11,0x11,0x16,0x1f,0x1f,0x1f,0x2c,
+		0x26,0x26,0x26,0x3d,0x32,0x32,0x32,0x4a,0x3d,0x3d,0x3d,0x51,0x45,0x45,0x45,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,
+		0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x48,0x48,0x48,0x53,0x45,0x45,0x45,0x53,
+		0x3d,0x3d,0x3d,0x51,0x32,0x32,0x32,0x4a,0x26,0x26,0x26,0x3d,0x1f,0x1f,0x1f,0x2c,0x11,0x11,0x11,0x16,0x06,0x06,0x06,0x08,
+		0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x02,0x02,0x03,0x06,0x06,0x06,0x08,0x0b,0x0b,0x0b,0x0f,
+		0x0e,0x0e,0x0e,0x13,0x10,0x10,0x10,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,
+		0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x0f,0x0f,0x0f,0x16,0x10,0x10,0x10,0x16,
+		0x0e,0x0e,0x0e,0x13,0x0b,0x0b,0x0b,0x0f,0x06,0x06,0x06,0x08,0x02,0x02,0x02,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
+};
diff --git a/client/x11/images/red_icon.c b/client/x11/images/red_icon.c
new file mode 100644
index 00000000..824eab8d
--- /dev/null
+++ b/client/x11/images/red_icon.c
@@ -0,0 +1,190 @@
+static const struct {
+	uint32_t width;
+	uint32_t height;
+	uint8_t pixmap[4096];
+	uint8_t mask[128];
+} _red_icon = { 32, 32, {
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0xf9,0xf9,0xf9,0x2e,0xfc,0xfc,0xfc,0xa7,0xff,0xfb,0xef,0xf8,0xf5,0xf5,0xf5,0xae,0xce,0xce,0xce,0x3e,
+		0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0xf5,0xf5,0xf5,0x19,0xfd,0xfd,0xfd,0x87,0xfe,0xfa,0xee,0xea,0xff,0xe3,0x9a,0xff,0xff,0xcd,0x5b,0xff,
+		0xff,0xe3,0xa8,0xff,0xfc,0xf7,0xea,0xef,0xea,0xea,0xea,0x95,0xb7,0xb7,0xb7,0x27,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0xff,0xff,0xff,0x0d,0xfd,0xfd,0xfd,0x69,0xfe,0xfc,0xf6,0xd7,0xff,0xee,0xbc,0xff,0xff,0xd9,0x6d,0xff,
+		0xff,0xcb,0x42,0xff,0xff,0xc2,0x3d,0xff,0xff,0xc5,0x55,0xff,0xff,0xd3,0x73,0xff,0xff,0xec,0xbf,0xff,0xf8,0xf5,0xef,0xdf,
+		0xe6,0xe6,0xe6,0x78,0xa6,0xa6,0xa6,0x17,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfc,0xfc,0xfc,0x4b,0xfc,0xfc,0xfc,0xc0,0xff,0xf6,0xd6,0xff,0xff,0xe4,0x89,0xff,
+		0xff,0xd6,0x58,0xff,0xff,0xd1,0x53,0xff,0xff,0xce,0x4f,0xff,0xff,0xc2,0x43,0xff,0xff,0xc0,0x55,0xff,0xff,0xc5,0x55,0xff,
+		0xff,0xc9,0x59,0xff,0xff,0xd9,0x85,0xff,0xff,0xf1,0xd0,0xff,0xf5,0xf5,0xf5,0xc9,0xdd,0xdd,0xdd,0x5a,0x00,0x00,0x00,0x08,
+		0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfa,0xfa,0xfa,0x33,0xfc,0xfc,0xfc,0xa4,0xff,0xfb,0xe6,0xfa,0xff,0xee,0xa5,0xff,
+		0xff,0xe1,0x6e,0xff,0xff,0xda,0x5e,0xff,0xff,0xd7,0x5d,0xff,0xff,0xd2,0x59,0xff,0xff,0xce,0x4e,0xff,0xff,0xbe,0x3f,0xff,
+		0xff,0xb7,0x4b,0xff,0xff,0xbe,0x52,0xff,0xff,0xc2,0x56,0xff,0xff,0xc6,0x54,0xff,0xff,0xce,0x62,0xff,0xff,0xe0,0x99,0xff,
+		0xfe,0xf5,0xe0,0xf9,0xf1,0xf1,0xf1,0xb1,0xcf,0xcf,0xcf,0x40,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf5,0xf5,0xf5,0x1a,0xfd,0xfd,0xfd,0x85,0xfe,0xfd,0xf3,0xea,0xff,0xf6,0xbe,0xff,
+		0xff,0xec,0x85,0xff,0xff,0xe4,0x6e,0xff,0xff,0xe0,0x6b,0xff,0xff,0xdc,0x67,0xff,0xff,0xd6,0x5e,0xff,0xff,0xd1,0x57,0xff,
+		0xff,0xcd,0x4d,0xff,0xff,0xbb,0x39,0xff,0xff,0xaf,0x40,0xff,0xff,0xb6,0x49,0xff,0xff,0xbb,0x4f,0xff,0xff,0xc1,0x55,0xff,
+		0xff,0xc5,0x58,0xff,0xff,0xc9,0x58,0xff,0xff,0xd3,0x6f,0xff,0xff,0xe7,0xac,0xff,0xfc,0xf8,0xeb,0xf0,0xeb,0xeb,0xeb,0x98,
+		0xbc,0xbc,0xbc,0x2a,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0x0e,0xfd,0xfd,0xfd,0x68,0xfe,0xfe,0xf8,0xdd,0xff,0xfc,0xd1,0xff,
+		0xff,0xf6,0x9b,0xff,0xff,0xee,0x7e,0xff,0xff,0xe9,0x78,0xff,0xff,0xe5,0x75,0xff,0xff,0xdf,0x6d,0xff,0xff,0xdb,0x65,0xff,
+		0xff,0xd6,0x5d,0xff,0xff,0xd1,0x55,0xff,0xff,0xcc,0x47,0xff,0xff,0xb6,0x31,0xff,0xff,0xa2,0x2e,0xff,0xff,0xac,0x3c,0xff,
+		0xff,0xb4,0x44,0xff,0xff,0xb9,0x4c,0xff,0xff,0xbf,0x52,0xff,0xff,0xc3,0x58,0xff,0xff,0xc8,0x59,0xff,0xff,0xcc,0x5b,0xff,
+		0xff,0xd8,0x7b,0xff,0xff,0xec,0xc0,0xff,0xf9,0xf7,0xf1,0xe1,0xe3,0xe3,0xe3,0x77,0xaa,0xaa,0xaa,0x18,0x00,0x00,0x00,0x03,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0xfe,0xfe,0xb6,0xff,0xff,0xf0,0xff,
+		0xff,0xfe,0xb0,0xff,0xff,0xf8,0x8b,0xff,0xff,0xf3,0x87,0xff,0xff,0xee,0x83,0xff,0xff,0xe9,0x7c,0xff,0xff,0xe4,0x73,0xff,
+		0xff,0xde,0x6c,0xff,0xff,0xda,0x63,0xff,0xff,0xd4,0x56,0xff,0xff,0xce,0x4d,0xff,0xff,0xd8,0x79,0xff,0xff,0xe8,0xbd,0xff,
+		0xff,0xca,0x8f,0xff,0xff,0xa9,0x3d,0xff,0xff,0xa6,0x30,0xff,0xff,0xaf,0x3f,0xff,0xff,0xb7,0x48,0xff,0xff,0xbb,0x4f,0xff,
+		0xff,0xc1,0x55,0xff,0xff,0xc6,0x5b,0xff,0xff,0xca,0x5c,0xff,0xff,0xcd,0x5c,0xff,0xff,0xdd,0x87,0xff,0xff,0xf6,0xe1,0xff,
+		0xf0,0xf0,0xf0,0xb9,0xe1,0xe1,0xe1,0x5f,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xfb,0xed,0xfe,0xf9,0xf7,0xd9,0xf9,0xff,0xff,0xff,0xd3,0xff,0xff,0xfe,0xa2,0xff,0xff,0xf3,0x84,0xff,0xff,0xed,0x7f,0xff,
+		0xff,0xe8,0x7a,0xff,0xff,0xe3,0x73,0xff,0xff,0xdd,0x67,0xff,0xff,0xd7,0x5b,0xff,0xff,0xda,0x73,0xff,0xff,0xeb,0xbb,0xff,
+		0xff,0xfe,0xed,0xff,0xff,0xff,0xe4,0xff,0xff,0xff,0xeb,0xff,0xff,0xec,0xd4,0xff,0xff,0xc1,0x77,0xff,0xff,0xa8,0x37,0xff,
+		0xff,0xaa,0x36,0xff,0xff,0xb3,0x44,0xff,0xff,0xba,0x4c,0xff,0xff,0xbd,0x4e,0xff,0xff,0xc0,0x4e,0xff,0xff,0xce,0x6e,0xff,
+		0xff,0xe9,0xb7,0xff,0xea,0xf9,0xed,0xff,0xf3,0xf9,0xf7,0xee,0xdf,0xdf,0xdf,0x9e,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0x06,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf3,0xcc,0xfa,0xf1,0xce,0x2f,0xef,0xff,0xdf,0x7e,0xfa,0xff,0xfa,0xea,0xf3,0xff,
+		0xff,0xff,0xc3,0xff,0xff,0xf4,0x8a,0xff,0xff,0xe6,0x71,0xff,0xff,0xe0,0x67,0xff,0xff,0xdf,0x72,0xff,0xff,0xea,0xaf,0xff,
+		0xff,0xfa,0xe9,0xff,0xff,0xff,0xe6,0xff,0xff,0xff,0xcb,0xff,0xff,0xff,0xc5,0xff,0xff,0xff,0xc6,0xff,0xff,0xff,0xd9,0xff,
+		0xff,0xff,0xf0,0xff,0xff,0xe1,0xbf,0xff,0xff,0xb8,0x60,0xff,0xff,0xa7,0x33,0xff,0xff,0xaa,0x33,0xff,0xff,0xb9,0x4f,0xff,
+		0xff,0xda,0x9f,0xff,0xf6,0xf6,0xe7,0xff,0xb6,0xf8,0xe7,0xff,0x72,0xed,0xc0,0xff,0xe0,0xf3,0xeb,0xe9,0xd2,0xd2,0xd2,0xa0,
+		0x00,0x00,0x00,0x22,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf3,0xd2,0xfa,0xf1,0xc4,0x14,0xeb,0xff,
+		0xb9,0x00,0xe7,0xff,0xc5,0x2e,0xef,0xff,0xe5,0xa2,0xfc,0xff,0xfc,0xf4,0xea,0xff,0xff,0xfa,0xa8,0xff,0xff,0xed,0xa0,0xff,
+		0xff,0xf9,0xde,0xff,0xff,0xff,0xec,0xff,0xff,0xff,0xd1,0xff,0xff,0xff,0xc5,0xff,0xff,0xff,0xc8,0xff,0xff,0xff,0xc9,0xff,
+		0xff,0xff,0xc9,0xff,0xff,0xff,0xc5,0xff,0xff,0xff,0xc9,0xff,0xff,0xff,0xe4,0xff,0xff,0xf9,0xe8,0xff,0xff,0xd5,0xa2,0xff,
+		0xff,0xc7,0x7f,0xff,0xfd,0xef,0xda,0xff,0xca,0xfb,0xf1,0xff,0x7d,0xf0,0xca,0xff,0x55,0xe9,0xb1,0xff,0x5a,0xe9,0xb4,0xff,
+		0xe2,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xf2,0xd2,0xfa,0xf1,0xc2,0x1b,0xe9,0xff,0xb9,0x00,0xe6,0xff,0xb5,0x00,0xe5,0xff,0xb5,0x00,0xe5,0xff,0xc7,0x48,0xf1,0xff,
+		0xeb,0xc1,0xf8,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xee,0xff,0xff,0xff,0xc6,0xff,0xff,0xff,0xc4,0xff,0xff,0xff,0xc8,0xff,
+		0xff,0xff,0xca,0xff,0xff,0xff,0xc9,0xff,0xff,0xff,0xc9,0xff,0xff,0xff,0xc9,0xff,0xff,0xff,0xc6,0xff,0xff,0xff,0xc2,0xff,
+		0xff,0xff,0xdc,0xff,0xff,0xff,0xff,0xff,0xe8,0xfc,0xf8,0xff,0x93,0xf4,0xd6,0xff,0x5b,0xe9,0xb5,0xff,0x58,0xe9,0xb3,0xff,
+		0x60,0xea,0xb7,0xff,0x61,0xea,0xb7,0xff,0xe2,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf2,0xd2,0xfa,0xf1,0xbd,0x1b,0xe7,0xff,0xb3,0x00,0xe4,0xff,0xb5,0x07,0xe4,0xff,
+		0xb2,0x04,0xe3,0xff,0xa7,0x00,0xe0,0xff,0xbe,0x3c,0xea,0xff,0xfe,0xfb,0xff,0xff,0xff,0xff,0xfd,0xff,0xff,0xff,0xf1,0xff,
+		0xff,0xff,0xd7,0xff,0xff,0xfe,0xc4,0xff,0xff,0xff,0xc4,0xff,0xff,0xff,0xca,0xff,0xff,0xff,0xc9,0xff,0xff,0xff,0xc5,0xff,
+		0xff,0xff,0xcf,0xff,0xff,0xff,0xe9,0xff,0xff,0xfd,0xec,0xff,0xff,0xfc,0xdd,0xff,0xbd,0xf7,0xe2,0xff,0x51,0xe7,0xaf,0xff,
+		0x5d,0xe9,0xb5,0xff,0x62,0xea,0xb7,0xff,0x60,0xea,0xb7,0xff,0x61,0xea,0xb7,0xff,0xe2,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,
+		0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf1,0xd3,0xf9,0xf1,0xb9,0x1c,0xe5,0xff,
+		0xae,0x00,0xe2,0xff,0xb0,0x07,0xe2,0xff,0xae,0x07,0xe2,0xff,0xa7,0x00,0xe0,0xff,0xba,0x3b,0xe6,0xff,0xfd,0xf9,0xfe,0xff,
+		0xff,0xff,0xff,0xff,0xff,0xfe,0xff,0xff,0xff,0xfe,0xfc,0xff,0xff,0xff,0xeb,0xff,0xff,0xfe,0xc9,0xff,0xff,0xfd,0xba,0xff,
+		0xff,0xfd,0xc2,0xff,0xff,0xff,0xdf,0xff,0xff,0xff,0xf6,0xff,0xff,0xfc,0xea,0xff,0xff,0xf9,0xc5,0xff,0xff,0xfa,0xc2,0xff,
+		0xbd,0xf5,0xe0,0xff,0x53,0xe7,0xae,0xff,0x5d,0xe8,0xb4,0xff,0x61,0xea,0xb7,0xff,0x60,0xea,0xb7,0xff,0x61,0xea,0xb7,0xff,
+		0xe2,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xf0,0xd3,0xf9,0xf1,0xb4,0x1c,0xe3,0xff,0xaa,0x00,0xe0,0xff,0xab,0x07,0xe0,0xff,0xa9,0x07,0xe0,0xff,0xa2,0x00,0xdd,0xff,
+		0xb6,0x3d,0xe4,0xff,0xfd,0xfa,0xff,0xff,0xff,0xff,0xfc,0xff,0xff,0xfe,0xf6,0xff,0xff,0xfd,0xf0,0xff,0xff,0xfd,0xf2,0xff,
+		0xff,0xfe,0xf2,0xff,0xff,0xfe,0xdf,0xff,0xff,0xfe,0xec,0xff,0xff,0xfd,0xfa,0xff,0xff,0xfb,0xe6,0xff,0xff,0xf9,0xcf,0xff,
+		0xff,0xf8,0xbc,0xff,0xff,0xf9,0xc1,0xff,0xba,0xf5,0xde,0xff,0x49,0xe3,0xa5,0xff,0x55,0xe6,0xac,0xff,0x5d,0xe9,0xb3,0xff,
+		0x5f,0xea,0xb6,0xff,0x61,0xea,0xb7,0xff,0xe2,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xef,0xd3,0xf8,0xf1,0xb0,0x1d,0xe2,0xff,0xa5,0x01,0xde,0xff,0xa6,0x08,0xde,0xff,
+		0xa4,0x08,0xde,0xff,0x9e,0x00,0xdb,0xff,0xb3,0x3d,0xe3,0xff,0xfd,0xfa,0xfb,0xff,0xff,0xff,0xf1,0xff,0xff,0xfc,0xe9,0xff,
+		0xff,0xfc,0xe2,0xff,0xff,0xfb,0xd9,0xff,0xff,0xfa,0xd7,0xff,0xff,0xfe,0xf5,0xff,0xff,0xff,0xfe,0xff,0xff,0xfc,0xeb,0xff,
+		0xff,0xfb,0xda,0xff,0xff,0xf9,0xcb,0xff,0xff,0xf7,0xb7,0xff,0xff,0xf9,0xbd,0xff,0xb8,0xf4,0xdb,0xff,0x41,0xe1,0x9e,0xff,
+		0x4c,0xe4,0xa5,0xff,0x54,0xe7,0xab,0xff,0x5a,0xe8,0xb1,0xff,0x5f,0xe9,0xb6,0xff,0xe3,0xf3,0xed,0xe9,0xd1,0xd1,0xd1,0xa1,
+		0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xee,0xd3,0xf8,0xf1,0xac,0x1d,0xe0,0xff,
+		0xa0,0x01,0xdc,0xff,0xa1,0x09,0xdc,0xff,0xa0,0x09,0xdc,0xff,0x99,0x00,0xd9,0xff,0xaf,0x3d,0xe3,0xff,0xfd,0xfa,0xf6,0xff,
+		0xff,0xff,0xe4,0xff,0xff,0xfb,0xdd,0xff,0xff,0xfb,0xd5,0xff,0xff,0xfa,0xce,0xff,0xff,0xf9,0xc5,0xff,0xff,0xfc,0xe8,0xff,
+		0xff,0xfe,0xfa,0xff,0xff,0xfc,0xe6,0xff,0xff,0xfa,0xd5,0xff,0xff,0xf8,0xc6,0xff,0xff,0xf6,0xb2,0xff,0xff,0xf9,0xb9,0xff,
+		0xb4,0xf3,0xd8,0xff,0x39,0xdf,0x97,0xff,0x43,0xe2,0x9e,0xff,0x4b,0xe4,0xa4,0xff,0x50,0xe5,0xa9,0xff,0x57,0xe7,0xae,0xff,
+		0xe2,0xf3,0xec,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xed,0xd3,0xf8,0xf1,0xa7,0x1e,0xde,0xff,0x9b,0x02,0xda,0xff,0x9c,0x09,0xda,0xff,0x9b,0x0a,0xda,0xff,0x93,0x00,0xd7,0xff,
+		0xaa,0x3d,0xe2,0xff,0xfd,0xfb,0xf0,0xff,0xff,0xfe,0xd7,0xff,0xff,0xfa,0xd0,0xff,0xff,0xf9,0xca,0xff,0xff,0xf8,0xc1,0xff,
+		0xff,0xf7,0xb9,0xff,0xff,0xfc,0xe3,0xff,0xff,0xfe,0xf6,0xff,0xff,0xfb,0xdf,0xff,0xff,0xfa,0xcf,0xff,0xff,0xf8,0xc0,0xff,
+		0xff,0xf6,0xaa,0xff,0xff,0xf8,0xb1,0xff,0xb3,0xf2,0xd7,0xff,0x31,0xdd,0x90,0xff,0x3b,0xde,0x97,0xff,0x43,0xe2,0x9d,0xff,
+		0x48,0xe3,0xa1,0xff,0x4f,0xe4,0xa7,0xff,0xe1,0xf3,0xeb,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xed,0xd3,0xf7,0xf1,0xa3,0x1f,0xdc,0xff,0x96,0x03,0xd7,0xff,0x98,0x0a,0xd8,0xff,
+		0x95,0x0a,0xd7,0xff,0x8a,0x00,0xd3,0xff,0xa6,0x3d,0xe0,0xff,0xfe,0xfe,0xf4,0xff,0xff,0xff,0xd0,0xff,0xff,0xf8,0xbf,0xff,
+		0xff,0xf8,0xbb,0xff,0xff,0xf7,0xb5,0xff,0xff,0xf6,0xad,0xff,0xff,0xfb,0xde,0xff,0xff,0xfd,0xf2,0xff,0xff,0xfa,0xda,0xff,
+		0xff,0xf9,0xca,0xff,0xff,0xf6,0xb7,0xff,0xff,0xf5,0xa7,0xff,0xff,0xfb,0xca,0xff,0xae,0xf0,0xd3,0xff,0x26,0xd9,0x85,0xff,
+		0x33,0xdd,0x90,0xff,0x3b,0xdf,0x96,0xff,0x40,0xe0,0x9b,0xff,0x47,0xe2,0xa1,0xff,0xe0,0xf2,0xeb,0xe9,0xd1,0xd1,0xd1,0xa1,
+		0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xeb,0xd4,0xf7,0xf1,0x9f,0x20,0xda,0xff,
+		0x91,0x03,0xd5,0xff,0x8e,0x05,0xd4,0xff,0x8e,0x06,0xd4,0xff,0xa3,0x1e,0xdc,0xff,0xc9,0x4c,0xea,0xff,0xe9,0xa6,0xf7,0xff,
+		0xfa,0xec,0xf4,0xff,0xff,0xff,0xd3,0xff,0xff,0xfa,0xaf,0xff,0xff,0xf4,0xa2,0xff,0xff,0xf4,0xa0,0xff,0xff,0xfb,0xda,0xff,
+		0xff,0xfc,0xf0,0xff,0xff,0xf9,0xd2,0xff,0xff,0xf8,0xc1,0xff,0xff,0xfa,0xc5,0xff,0xfe,0xfc,0xe2,0xff,0xbf,0xf7,0xe4,0xff,
+		0x57,0xe5,0xac,0xff,0x23,0xd8,0x83,0xff,0x2b,0xd9,0x86,0xff,0x32,0xdd,0x8e,0xff,0x38,0xde,0x94,0xff,0x3f,0xe0,0x99,0xff,
+		0xde,0xf2,0xe9,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xeb,0xd4,0xf7,0xf1,0x97,0x1d,0xd7,0xff,0x85,0x00,0xd1,0xff,0x9c,0x19,0xda,0xff,0xc7,0x4b,0xea,0xff,0xe2,0x69,0xf4,0xff,
+		0xe2,0x67,0xf4,0xff,0xd7,0x55,0xf0,0xff,0xdc,0x70,0xf5,0xff,0xed,0xbb,0xfb,0xff,0xfd,0xf6,0xe7,0xff,0xff,0xff,0xb3,0xff,
+		0xff,0xf4,0x8d,0xff,0xff,0xf9,0xd0,0xff,0xff,0xfc,0xea,0xff,0xff,0xf9,0xd2,0xff,0xff,0xfc,0xe4,0xff,0xd8,0xfb,0xec,0xff,
+		0x7f,0xf1,0xd1,0xff,0x38,0xe7,0xad,0xff,0x32,0xe6,0xa7,0xff,0x38,0xe4,0xa3,0xff,0x2f,0xdd,0x91,0xff,0x2a,0xd8,0x86,0xff,
+		0x2d,0xda,0x88,0xff,0x35,0xdd,0x92,0xff,0xde,0xf2,0xe8,0xe9,0xd1,0xd1,0xd1,0xa1,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x0a,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe9,0xd2,0xf7,0xf8,0x9c,0x22,0xda,0xff,0xbd,0x3d,0xe6,0xff,0xea,0x73,0xf7,0xff,
+		0xf1,0x7b,0xfa,0xff,0xea,0x73,0xf6,0xff,0xe3,0x6c,0xf5,0xff,0xe0,0x67,0xf3,0xff,0xdb,0x5c,0xf2,0xff,0xd8,0x58,0xf1,0xff,
+		0xdf,0x82,0xf8,0xff,0xf2,0xcd,0xf7,0xff,0xff,0xfb,0xce,0xff,0xff,0xfd,0xdd,0xff,0xff,0xfe,0xf5,0xff,0xe9,0xfd,0xf0,0xff,
+		0x9a,0xf5,0xde,0xff,0x4d,0xed,0xbf,0xff,0x37,0xe9,0xb1,0xff,0x3e,0xe9,0xb2,0xff,0x40,0xe9,0xaf,0xff,0x3d,0xe8,0xac,0xff,
+		0x3b,0xe7,0xaa,0xff,0x36,0xe2,0x9f,0xff,0x2b,0xdb,0x8c,0xff,0x24,0xd8,0x84,0xff,0xdb,0xf2,0xe8,0xed,0xd4,0xd4,0xd4,0xa5,
+		0x00,0x00,0x00,0x24,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf4,0xe9,0xf8,0xd7,0xee,0xa1,0xf8,0xff,
+		0xfd,0x88,0xfe,0xff,0xfa,0x82,0xfd,0xff,0xf2,0x7d,0xfa,0xff,0xee,0x79,0xf8,0xff,0xeb,0x74,0xf7,0xff,0xe6,0x6f,0xf6,0xff,
+		0xe3,0x6b,0xf5,0xff,0xe0,0x65,0xf3,0xff,0xd9,0x58,0xf1,0xff,0xd7,0x5a,0xf2,0xff,0xe6,0x94,0xfb,0xff,0xf9,0xf5,0xfe,0xff,
+		0xb5,0xfd,0xea,0xff,0x5e,0xf3,0xcd,0xff,0x3f,0xee,0xbf,0xff,0x41,0xee,0xbc,0xff,0x45,0xed,0xbb,0xff,0x44,0xec,0xb9,0xff,
+		0x42,0xeb,0xb5,0xff,0x40,0xea,0xb1,0xff,0x3d,0xe8,0xae,0xff,0x36,0xe7,0xaa,0xff,0x33,0xe5,0xa5,0xff,0x6a,0xe8,0xb3,0xff,
+		0xe1,0xec,0xe7,0xdb,0xbf,0xbf,0xbf,0x8c,0x00,0x00,0x00,0x23,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0xbb,0xbc,0xbb,0x2a,0xe6,0xe6,0xe4,0xab,0xfd,0xd9,0xfd,0xfd,0xfc,0xa0,0xfe,0xff,0xf8,0x80,0xfc,0xff,0xf4,0x7d,0xfa,0xff,
+		0xf2,0x7b,0xf9,0xff,0xed,0x77,0xf8,0xff,0xe9,0x72,0xf7,0xff,0xe6,0x6e,0xf5,0xff,0xe2,0x6a,0xf4,0xff,0xdb,0x5c,0xf2,0xff,
+		0xe1,0x62,0xf3,0xff,0xe6,0xe5,0xf9,0xff,0x60,0xfb,0xd2,0xff,0x43,0xf1,0xc7,0xff,0x4c,0xf1,0xc7,0xff,0x4a,0xf0,0xc4,0xff,
+		0x49,0xef,0xc0,0xff,0x47,0xee,0xbe,0xff,0x44,0xed,0xba,0xff,0x3d,0xeb,0xb5,0xff,0x36,0xe9,0xaf,0xff,0x5d,0xed,0xbd,0xff,
+		0xb7,0xf6,0xe0,0xff,0xd9,0xdb,0xdb,0xc1,0x6b,0x6b,0x6b,0x5f,0x2a,0x2a,0x2a,0x37,0x00,0x00,0x00,0x19,0x00,0x00,0x00,0x06,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x14,0xaf,0xb4,0xaf,0x64,0xe9,0xe6,0xe9,0xce,
+		0xfe,0xca,0xff,0xff,0xfc,0x97,0xfe,0xff,0xf7,0x7e,0xfc,0xff,0xf3,0x7c,0xfa,0xff,0xef,0x7a,0xf9,0xff,0xec,0x76,0xf7,0xff,
+		0xe8,0x71,0xf6,0xff,0xe2,0x67,0xf5,0xff,0xe9,0x6f,0xf6,0xff,0xe5,0xe7,0xf9,0xff,0x66,0xfc,0xd8,0xff,0x4b,0xf4,0xcf,0xff,
+		0x4f,0xf3,0xcd,0xff,0x4d,0xf2,0xca,0xff,0x4c,0xf1,0xc6,0xff,0x46,0xef,0xc2,0xff,0x3e,0xee,0xbd,0xff,0x53,0xef,0xc2,0xff,
+		0xa3,0xf6,0xdd,0xff,0xe2,0xeb,0xe8,0xdf,0xa5,0x9f,0xa1,0x83,0x00,0x00,0x00,0x3b,0x00,0x00,0x00,0x2a,0x00,0x00,0x00,0x17,
+		0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x04,
+		0x00,0x00,0x00,0x0d,0x4e,0x4f,0x4e,0x29,0xc2,0xc7,0xc1,0x8a,0xf4,0xe8,0xf3,0xe6,0xfe,0xbb,0xff,0xff,0xfb,0x8b,0xfd,0xff,
+		0xf5,0x7b,0xfb,0xff,0xf3,0x7b,0xf9,0xff,0xef,0x79,0xf8,0xff,0xe9,0x6f,0xf7,0xff,0xef,0x77,0xf8,0xff,0xe7,0xe9,0xf9,0xff,
+		0x69,0xfe,0xde,0xff,0x4e,0xf6,0xd5,0xff,0x53,0xf5,0xd3,0xff,0x4d,0xf4,0xcf,0xff,0x44,0xf2,0xc9,0xff,0x50,0xf3,0xca,0xff,
+		0x92,0xf7,0xdd,0xff,0xdb,0xf4,0xee,0xf4,0xcb,0xc5,0xc7,0xa8,0x4a,0x49,0x49,0x53,0x00,0x00,0x00,0x31,0x00,0x00,0x00,0x1f,
+		0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x12,0x85,0x88,0x85,0x42,
+		0xd6,0xdb,0xd6,0xab,0xf9,0xe3,0xf9,0xf5,0xfe,0xaf,0xff,0xff,0xfa,0x84,0xfd,0xff,0xf5,0x7b,0xfb,0xff,0xf0,0x77,0xf9,0xff,
+		0xf5,0x7f,0xf9,0xff,0xe8,0xea,0xfa,0xff,0x6d,0xff,0xe3,0xff,0x52,0xf9,0xdb,0xff,0x4d,0xf7,0xd6,0xff,0x4e,0xf6,0xd3,0xff,
+		0x83,0xfa,0xe0,0xff,0xd4,0xfc,0xf3,0xff,0xe1,0xdd,0xdf,0xc9,0x82,0x7e,0x7f,0x6e,0x00,0x00,0x00,0x37,0x00,0x00,0x00,0x26,
+		0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x17,0xa8,0xac,0xa7,0x62,0xe5,0xe7,0xe5,0xcb,0xfe,0xdc,0xfe,0xff,
+		0xfd,0x9e,0xff,0xff,0xf7,0x78,0xfc,0xff,0xfa,0x80,0xfb,0xff,0xe9,0xeb,0xfb,0xff,0x69,0xff,0xe7,0xff,0x49,0xfa,0xdf,0xff,
+		0x75,0xfb,0xe4,0xff,0xc6,0xfe,0xf4,0xff,0xed,0xec,0xec,0xe5,0xac,0xa6,0xa8,0x90,0x20,0x1f,0x1f,0x44,0x00,0x00,0x00,0x2d,
+		0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x0d,
+		0x41,0x43,0x41,0x25,0xc1,0xc6,0xc0,0x84,0xf0,0xeb,0xef,0xe6,0xfe,0xc8,0xff,0xff,0xff,0x98,0xfe,0xff,0xe5,0xec,0xfc,0xff,
+		0x7d,0xff,0xee,0xff,0xad,0xff,0xf4,0xff,0xef,0xf7,0xf6,0xf7,0xcd,0xc5,0xc6,0xb3,0x58,0x57,0x57,0x5a,0x00,0x00,0x00,0x33,
+		0x00,0x00,0x00,0x21,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x11,0x7e,0x80,0x7d,0x3f,0xd2,0xd5,0xd1,0xaa,
+		0xfc,0xef,0xfc,0xfd,0xf4,0xf9,0xfd,0xff,0xeb,0xfd,0xfb,0xff,0xe2,0xdc,0xdd,0xd4,0x8a,0x86,0x86,0x77,0x00,0x00,0x00,0x39,
+		0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x16,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,
+		0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x16,0xa5,0xa7,0xa4,0x60,0xdc,0xdb,0xd9,0xba,0xb6,0xb2,0xb1,0x97,0x29,0x29,0x29,0x47,
+		0x00,0x00,0x00,0x2f,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x04,0x2d,0x2d,0x2d,0x10,0x9b,0x9b,0x9a,0x40,
+		0x58,0x57,0x56,0x3a,0x00,0x00,0x00,0x22,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
+
+		{0x00,0x07,0xc0,0x00,0x00,0x1f,0xf0,0x00,0x00,0x7f,0xfc,0x00,
+		 0x00,0xff,0xfe,0x00,0x03,0xff,0xff,0x80,0x0f,0xff,0xff,0xe0,
+		 0x3f,0xff,0xff,0xf8,0x3f,0xff,0xff,0xfc,0x3f,0xff,0xff,0xfe,
+		 0x3f,0xff,0xff,0xfe,0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,
+		 0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,
+		 0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,
+		 0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xff,
+		 0x3f,0xff,0xff,0xff,0x3f,0xff,0xff,0xfe,0x3f,0xff,0xff,0xfe,
+		 0x1f,0xff,0xff,0xfe,0x0f,0xff,0xff,0xf8,0x03,0xff,0xff,0xe0,
+		 0x01,0xff,0xff,0xc0,0x00,0x7f,0xff,0x00,0x00,0x1f,0xfc,0x00,
+		 0x00,0x07,0xf8,0x00,0x00,0x03,0xe0,0x00}
+};
diff --git a/client/x11/images/splash_image.c b/client/x11/images/splash_image.c
new file mode 100644
index 00000000..6914fff3
--- /dev/null
+++ b/client/x11/images/splash_image.c
@@ -0,0 +1,51206 @@
+static const struct {
+	uint32_t width;
+	uint32_t height;
+	uint8_t pixel_data[1228800];
+} _splash_image = { 640, 480, {
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x1f,0x1f,0x1f,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x20,0x20,0x20,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1e,0x1e,0x1e,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x1f,0x1f,0x1f,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x12,0x12,0x12,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1d,0x1d,0x1d,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,
+		0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x17,0x17,0x17,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,
+		0x19,0x19,0x19,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,0x11,0x11,0x11,0x00,0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,0x10,0x10,0x10,0x00,0x16,0x16,0x16,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x12,0x12,0x12,0x00,0x18,0x18,0x18,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0c,0x0c,0x0c,0x00,0x12,0x12,0x12,0x00,
+		0x18,0x18,0x18,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0e,0x0e,0x0e,0x00,
+		0x16,0x16,0x16,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0e,0x0e,0x0e,0x00,0x16,0x16,0x16,0x00,0x1d,0x1d,0x1d,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x0d,0x0d,0x0d,0x00,0x14,0x14,0x14,0x00,0x1b,0x1b,0x1b,0x00,0x20,0x20,0x20,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x0d,0x0d,0x0d,0x00,0x16,0x16,0x16,0x00,0x1d,0x1d,0x1d,0x00,0x21,0x21,0x21,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x14,0x14,0x14,0x00,0x1c,0x1c,0x1c,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,0x11,0x11,0x11,0x00,
+		0x19,0x19,0x19,0x00,0x20,0x20,0x20,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,
+		0x10,0x10,0x10,0x00,0x19,0x19,0x19,0x00,0x1f,0x1f,0x1f,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,0x15,0x15,0x15,0x00,0x1c,0x1c,0x1c,0x00,0x21,0x21,0x21,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x11,0x11,0x11,0x00,0x1b,0x1b,0x1b,0x00,0x20,0x20,0x20,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,0x16,0x16,0x16,0x00,
+		0x1f,0x1f,0x1f,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,
+		0x11,0x11,0x11,0x00,0x1b,0x1b,0x1b,0x00,0x22,0x22,0x22,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,
+		0x18,0x18,0x18,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,
+		0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x0b,0x0b,0x0b,0x00,0x14,0x14,0x14,0x00,0x20,0x20,0x20,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x05,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,
+		0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x02,0x00,
+		0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x0f,0x0f,0x0f,0x00,0x17,0x17,0x17,0x00,0x21,0x21,0x21,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,
+		0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x06,0x05,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x06,0x05,0x04,0x00,0x06,0x05,0x04,0x00,0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0b,0x0b,0x0b,0x00,0x13,0x13,0x13,0x00,
+		0x1c,0x1c,0x1c,0x00,0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x07,0x04,0x00,
+		0x07,0x07,0x04,0x00,0x07,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x07,0x05,0x00,
+		0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,
+		0x05,0x05,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,
+		0x0e,0x0e,0x0e,0x00,0x16,0x16,0x16,0x00,0x1e,0x1e,0x1e,0x00,0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x04,0x04,0x02,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x07,0x04,0x00,0x08,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x08,0x07,0x05,0x00,
+		0x09,0x08,0x06,0x00,0x09,0x08,0x06,0x00,0x09,0x08,0x06,0x00,0x09,0x08,0x05,0x00,0x09,0x08,0x05,0x00,0x09,0x08,0x05,0x00,
+		0x09,0x08,0x05,0x00,0x09,0x08,0x06,0x00,0x09,0x08,0x06,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x05,0x00,0x08,0x07,0x05,0x00,
+		0x08,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,
+		0x05,0x04,0x03,0x00,0x05,0x04,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x11,0x11,0x11,0x00,0x1a,0x1a,0x1a,0x00,0x21,0x21,0x21,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x03,0x00,
+		0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x09,0x08,0x06,0x00,
+		0x09,0x08,0x05,0x00,0x09,0x08,0x06,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0b,0x09,0x07,0x00,0x0b,0x09,0x07,0x00,
+		0x0b,0x0a,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x09,0x07,0x00,
+		0x0b,0x09,0x07,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x05,0x00,0x09,0x08,0x05,0x00,0x09,0x08,0x06,0x00,
+		0x08,0x07,0x05,0x00,0x08,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x05,0x04,0x00,
+		0x05,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x13,0x13,0x13,0x00,0x1b,0x1b,0x1b,0x00,
+		0x22,0x22,0x22,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,
+		0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x07,0x04,0x00,0x08,0x07,0x05,0x00,
+		0x09,0x08,0x06,0x00,0x09,0x08,0x05,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0b,0x0a,0x07,0x00,0x0b,0x0a,0x07,0x00,
+		0x0c,0x0a,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0d,0x0c,0x07,0x00,0x0d,0x0c,0x07,0x00,0x0d,0x0c,0x07,0x00,0x0d,0x0c,0x08,0x00,
+		0x0d,0x0c,0x08,0x00,0x0d,0x0c,0x08,0x00,0x0d,0x0c,0x07,0x00,0x0d,0x0b,0x07,0x00,0x0d,0x0c,0x07,0x00,0x0c,0x0b,0x07,0x00,
+		0x0c,0x0b,0x07,0x00,0x0c,0x0a,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x05,0x00,
+		0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x08,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0b,0x0b,0x0b,0x00,
+		0x15,0x15,0x15,0x00,0x1f,0x1f,0x1f,0x00,0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,
+		0x08,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x09,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,0x0b,0x0a,0x07,0x00,
+		0x0c,0x0b,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0d,0x0c,0x08,0x00,0x0e,0x0d,0x08,0x00,0x0e,0x0d,0x08,0x00,0x0f,0x0d,0x09,0x00,
+		0x0f,0x0d,0x09,0x00,0x0f,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,
+		0x10,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x0f,0x0d,0x08,0x00,0x0f,0x0d,0x09,0x00,0x0e,0x0d,0x08,0x00,0x0e,0x0d,0x08,0x00,
+		0x0d,0x0c,0x07,0x00,0x0d,0x0c,0x07,0x00,0x0c,0x0a,0x07,0x00,0x0c,0x0a,0x06,0x00,0x0b,0x09,0x07,0x00,0x0a,0x09,0x06,0x00,
+		0x09,0x08,0x05,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x0d,0x0d,0x0d,0x00,0x16,0x16,0x16,0x00,0x1f,0x1f,0x1f,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x08,0x08,0x05,0x00,0x09,0x08,0x06,0x00,0x0a,0x09,0x07,0x00,
+		0x0b,0x0a,0x07,0x00,0x0c,0x0a,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0d,0x0c,0x08,0x00,0x0e,0x0d,0x08,0x00,0x0f,0x0e,0x09,0x00,
+		0x10,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x11,0x0f,0x0a,0x00,0x11,0x0f,0x0a,0x00,0x12,0x10,0x0a,0x00,0x12,0x10,0x0a,0x00,
+		0x13,0x10,0x0b,0x00,0x13,0x10,0x0b,0x00,0x13,0x10,0x0b,0x00,0x13,0x10,0x0b,0x00,0x13,0x10,0x0b,0x00,0x12,0x10,0x0a,0x00,
+		0x12,0x10,0x0a,0x00,0x12,0x10,0x0a,0x00,0x11,0x0f,0x09,0x00,0x11,0x0f,0x0a,0x00,0x10,0x0e,0x09,0x00,0x0f,0x0d,0x08,0x00,
+		0x0f,0x0d,0x08,0x00,0x0e,0x0c,0x08,0x00,0x0d,0x0b,0x07,0x00,0x0c,0x0a,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0a,0x09,0x06,0x00,
+		0x0a,0x09,0x05,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x05,0x04,0x03,0x00,0x05,0x05,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x0f,0x0f,0x0f,0x00,0x19,0x19,0x19,0x00,0x20,0x20,0x20,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,
+		0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x08,0x08,0x05,0x00,
+		0x09,0x08,0x06,0x00,0x0a,0x09,0x06,0x00,0x0b,0x0a,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0d,0x0c,0x08,0x00,0x0e,0x0d,0x09,0x00,
+		0x0f,0x0e,0x09,0x00,0x10,0x0e,0x09,0x00,0x11,0x0f,0x0a,0x00,0x11,0x0f,0x0a,0x00,0x12,0x10,0x0a,0x00,0x13,0x11,0x0b,0x00,
+		0x14,0x11,0x0b,0x00,0x14,0x12,0x0b,0x00,0x15,0x13,0x0c,0x00,0x15,0x13,0x0c,0x00,0x16,0x13,0x0c,0x00,0x16,0x13,0x0c,0x00,
+		0x16,0x13,0x0c,0x00,0x16,0x13,0x0c,0x00,0x16,0x13,0x0c,0x00,0x15,0x13,0x0c,0x00,0x15,0x12,0x0b,0x00,0x15,0x12,0x0c,0x00,
+		0x14,0x11,0x0b,0x00,0x13,0x11,0x0a,0x00,0x13,0x10,0x0b,0x00,0x12,0x10,0x0a,0x00,0x11,0x0f,0x09,0x00,0x10,0x0e,0x09,0x00,
+		0x0f,0x0d,0x08,0x00,0x0e,0x0c,0x08,0x00,0x0d,0x0b,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0b,0x09,0x06,0x00,
+		0x0a,0x09,0x05,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,
+		0x05,0x04,0x03,0x00,0x05,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x10,0x10,0x10,0x00,
+		0x1a,0x1a,0x1a,0x00,0x21,0x21,0x21,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x04,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,
+		0x07,0x07,0x05,0x00,0x08,0x08,0x05,0x00,0x09,0x08,0x06,0x00,0x0a,0x09,0x06,0x00,0x0b,0x0a,0x07,0x00,0x0c,0x0b,0x07,0x00,
+		0x0d,0x0c,0x08,0x00,0x0e,0x0d,0x08,0x00,0x0f,0x0e,0x09,0x00,0x10,0x0f,0x0a,0x00,0x11,0x0f,0x0a,0x00,0x12,0x10,0x0b,0x00,
+		0x13,0x11,0x0b,0x00,0x14,0x12,0x0b,0x00,0x15,0x13,0x0c,0x00,0x16,0x13,0x0c,0x00,0x17,0x14,0x0d,0x00,0x18,0x15,0x0d,0x00,
+		0x18,0x15,0x0d,0x00,0x19,0x15,0x0e,0x00,0x19,0x16,0x0d,0x00,0x19,0x16,0x0d,0x00,0x19,0x16,0x0d,0x00,0x19,0x16,0x0d,0x00,
+		0x19,0x16,0x0d,0x00,0x19,0x15,0x0e,0x00,0x18,0x15,0x0d,0x00,0x18,0x15,0x0d,0x00,0x17,0x14,0x0c,0x00,0x17,0x13,0x0c,0x00,
+		0x16,0x13,0x0c,0x00,0x15,0x12,0x0c,0x00,0x14,0x11,0x0b,0x00,0x13,0x10,0x0b,0x00,0x12,0x10,0x0a,0x00,0x11,0x0f,0x0a,0x00,
+		0x10,0x0d,0x09,0x00,0x0f,0x0d,0x08,0x00,0x0e,0x0c,0x08,0x00,0x0d,0x0b,0x07,0x00,0x0c,0x0a,0x06,0x00,0x0b,0x09,0x06,0x00,
+		0x0a,0x09,0x05,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x05,0x04,0x00,
+		0x05,0x05,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x07,0x07,0x07,0x00,0x11,0x11,0x11,0x00,0x1b,0x1b,0x1b,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,
+		0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x07,0x05,0x00,0x08,0x08,0x05,0x00,0x09,0x09,0x06,0x00,0x0a,0x09,0x07,0x00,
+		0x0b,0x0a,0x07,0x00,0x0c,0x0b,0x08,0x00,0x0d,0x0c,0x08,0x00,0x0e,0x0d,0x09,0x00,0x0f,0x0e,0x09,0x00,0x10,0x0f,0x0a,0x00,
+		0x12,0x10,0x0b,0x00,0x13,0x11,0x0b,0x00,0x14,0x12,0x0c,0x00,0x15,0x13,0x0c,0x00,0x16,0x14,0x0d,0x00,0x18,0x15,0x0d,0x00,
+		0x19,0x16,0x0e,0x00,0x19,0x16,0x0d,0x00,0x1a,0x17,0x0e,0x00,0x1b,0x18,0x0f,0x00,0x1b,0x18,0x0f,0x00,0x1c,0x19,0x0f,0x00,
+		0x1c,0x18,0x0f,0x00,0x1d,0x19,0x0f,0x00,0x1d,0x19,0x0f,0x00,0x1d,0x19,0x0f,0x00,0x1c,0x18,0x0e,0x00,0x1c,0x18,0x0e,0x00,
+		0x1c,0x18,0x0f,0x00,0x1b,0x17,0x0e,0x00,0x1a,0x16,0x0d,0x00,0x1a,0x16,0x0d,0x00,0x19,0x15,0x0d,0x00,0x19,0x15,0x0e,0x00,
+		0x18,0x14,0x0d,0x00,0x17,0x14,0x0d,0x00,0x16,0x13,0x0c,0x00,0x15,0x12,0x0b,0x00,0x13,0x10,0x0b,0x00,0x12,0x0f,0x0a,0x00,
+		0x11,0x0e,0x0a,0x00,0x10,0x0d,0x09,0x00,0x0e,0x0c,0x08,0x00,0x0d,0x0b,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0a,0x09,0x06,0x00,
+		0x09,0x08,0x05,0x00,0x09,0x08,0x05,0x00,0x08,0x07,0x04,0x00,0x07,0x06,0x05,0x00,0x06,0x05,0x04,0x00,0x05,0x05,0x03,0x00,
+		0x05,0x05,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x11,0x11,0x11,0x00,0x1b,0x1b,0x1b,0x00,0x23,0x23,0x23,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x04,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,
+		0x09,0x09,0x06,0x00,0x0a,0x09,0x07,0x00,0x0b,0x0a,0x07,0x00,0x0c,0x0b,0x08,0x00,0x0d,0x0c,0x09,0x00,0x0e,0x0d,0x09,0x00,
+		0x0f,0x0e,0x09,0x00,0x11,0x10,0x0b,0x00,0x12,0x11,0x0b,0x00,0x13,0x11,0x0b,0x00,0x15,0x13,0x0c,0x00,0x16,0x14,0x0d,0x00,
+		0x17,0x15,0x0d,0x00,0x19,0x16,0x0e,0x00,0x19,0x16,0x0e,0x00,0x1b,0x18,0x0f,0x00,0x1c,0x19,0x0f,0x00,0x1d,0x1a,0x10,0x00,
+		0x1e,0x1a,0x10,0x00,0x1f,0x1b,0x10,0x00,0x1f,0x1b,0x10,0x00,0x20,0x1c,0x11,0x00,0x20,0x1c,0x10,0x00,0x20,0x1c,0x11,0x00,
+		0x21,0x1c,0x11,0x00,0x21,0x1c,0x11,0x00,0x20,0x1c,0x10,0x00,0x20,0x1b,0x10,0x00,0x20,0x1b,0x10,0x00,0x1f,0x1b,0x10,0x00,
+		0x1f,0x1a,0x10,0x00,0x1e,0x1a,0x10,0x00,0x1d,0x18,0x0f,0x00,0x1c,0x18,0x0f,0x00,0x1b,0x17,0x0f,0x00,0x1b,0x17,0x0f,0x00,
+		0x1a,0x16,0x0e,0x00,0x19,0x15,0x0e,0x00,0x17,0x13,0x0d,0x00,0x15,0x12,0x0c,0x00,0x14,0x11,0x0b,0x00,0x12,0x10,0x0a,0x00,
+		0x11,0x0e,0x0a,0x00,0x10,0x0d,0x09,0x00,0x0f,0x0c,0x08,0x00,0x0c,0x0b,0x07,0x00,0x0b,0x0a,0x06,0x00,0x0a,0x09,0x06,0x00,
+		0x09,0x08,0x05,0x00,0x08,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x05,0x05,0x03,0x00,
+		0x05,0x05,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x11,0x11,0x11,0x00,
+		0x1b,0x1b,0x1b,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x04,0x03,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x09,0x09,0x06,0x00,0x09,0x09,0x06,0x00,0x0b,0x0a,0x07,0x00,0x0c,0x0b,0x08,0x00,
+		0x0d,0x0c,0x09,0x00,0x0e,0x0d,0x09,0x00,0x0f,0x0e,0x0a,0x00,0x11,0x10,0x0b,0x00,0x12,0x11,0x0b,0x00,0x13,0x12,0x0c,0x00,
+		0x15,0x13,0x0d,0x00,0x16,0x14,0x0d,0x00,0x18,0x15,0x0e,0x00,0x19,0x17,0x0e,0x00,0x1a,0x17,0x0f,0x00,0x1c,0x19,0x10,0x00,
+		0x1d,0x1a,0x10,0x00,0x1e,0x1b,0x10,0x00,0x1f,0x1b,0x11,0x00,0x21,0x1d,0x12,0x00,0x22,0x1e,0x12,0x00,0x23,0x1e,0x12,0x00,
+		0x23,0x1f,0x13,0x00,0x24,0x1f,0x13,0x00,0x24,0x1f,0x12,0x00,0x25,0x20,0x13,0x00,0x25,0x20,0x13,0x00,0x25,0x20,0x13,0x00,
+		0x25,0x20,0x13,0x00,0x25,0x1f,0x13,0x00,0x25,0x1f,0x13,0x00,0x24,0x1e,0x13,0x00,0x23,0x1e,0x12,0x00,0x24,0x1e,0x13,0x00,
+		0x23,0x1d,0x13,0x00,0x22,0x1d,0x12,0x00,0x22,0x1d,0x13,0x00,0x20,0x1b,0x12,0x00,0x1f,0x1a,0x11,0x00,0x1e,0x1a,0x11,0x00,
+		0x1c,0x18,0x10,0x00,0x1b,0x17,0x0f,0x00,0x1a,0x16,0x0f,0x00,0x17,0x13,0x0e,0x00,0x16,0x13,0x0d,0x00,0x13,0x10,0x0b,0x00,
+		0x12,0x0f,0x0b,0x00,0x10,0x0d,0x09,0x00,0x0e,0x0c,0x08,0x00,0x0d,0x0b,0x08,0x00,0x0b,0x09,0x06,0x00,0x0a,0x09,0x06,0x00,
+		0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x05,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x08,0x08,0x08,0x00,0x10,0x10,0x10,0x00,0x1b,0x1b,0x1b,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,
+		0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x07,0x07,0x05,0x00,0x08,0x08,0x06,0x00,0x09,0x09,0x06,0x00,
+		0x0a,0x0a,0x07,0x00,0x0b,0x0b,0x08,0x00,0x0c,0x0c,0x08,0x00,0x0e,0x0d,0x09,0x00,0x0f,0x0e,0x0a,0x00,0x10,0x0f,0x0a,0x00,
+		0x12,0x11,0x0c,0x00,0x13,0x12,0x0c,0x00,0x15,0x13,0x0d,0x00,0x16,0x14,0x0d,0x00,0x18,0x16,0x0e,0x00,0x19,0x17,0x0f,0x00,
+		0x1b,0x18,0x10,0x00,0x1c,0x19,0x10,0x00,0x1e,0x1b,0x11,0x00,0x1f,0x1c,0x11,0x00,0x21,0x1d,0x12,0x00,0x22,0x1e,0x12,0x00,
+		0x24,0x20,0x13,0x00,0x25,0x20,0x14,0x00,0x26,0x21,0x14,0x00,0x27,0x22,0x14,0x00,0x28,0x23,0x15,0x00,0x28,0x23,0x15,0x00,
+		0x29,0x23,0x15,0x00,0x29,0x23,0x15,0x00,0x29,0x23,0x15,0x00,0x2a,0x24,0x15,0x00,0x2a,0x24,0x15,0x00,0x2a,0x23,0x15,0x00,
+		0x2a,0x23,0x15,0x00,0x2a,0x24,0x16,0x00,0x29,0x23,0x16,0x00,0x29,0x23,0x17,0x00,0x29,0x23,0x17,0x00,0x29,0x24,0x18,0x00,
+		0x28,0x22,0x17,0x00,0x27,0x22,0x17,0x00,0x26,0x21,0x17,0x00,0x24,0x1f,0x16,0x00,0x22,0x1e,0x15,0x00,0x21,0x1d,0x14,0x00,
+		0x1f,0x1b,0x13,0x00,0x1c,0x19,0x12,0x00,0x1b,0x18,0x11,0x00,0x19,0x16,0x10,0x00,0x16,0x13,0x0d,0x00,0x13,0x11,0x0c,0x00,
+		0x12,0x0f,0x0b,0x00,0x0f,0x0d,0x09,0x00,0x0e,0x0c,0x08,0x00,0x0c,0x0a,0x07,0x00,0x0b,0x09,0x07,0x00,0x0a,0x09,0x06,0x00,
+		0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x07,0x07,0x05,0x00,0x06,0x05,0x04,0x00,0x05,0x05,0x03,0x00,0x05,0x05,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x10,0x10,0x10,0x00,0x1b,0x1b,0x1b,0x00,0x23,0x23,0x23,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,
+		0x04,0x03,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,0x07,0x07,0x05,0x00,
+		0x08,0x07,0x06,0x00,0x09,0x09,0x06,0x00,0x0a,0x09,0x07,0x00,0x0b,0x0a,0x08,0x00,0x0c,0x0b,0x08,0x00,0x0d,0x0c,0x09,0x00,
+		0x0f,0x0e,0x0a,0x00,0x10,0x0f,0x0a,0x00,0x11,0x10,0x0b,0x00,0x13,0x12,0x0c,0x00,0x14,0x13,0x0d,0x00,0x16,0x14,0x0e,0x00,
+		0x18,0x16,0x0e,0x00,0x19,0x17,0x0f,0x00,0x1b,0x19,0x10,0x00,0x1c,0x19,0x10,0x00,0x1e,0x1b,0x11,0x00,0x20,0x1d,0x12,0x00,
+		0x22,0x1e,0x13,0x00,0x23,0x1f,0x13,0x00,0x25,0x21,0x14,0x00,0x26,0x22,0x14,0x00,0x28,0x23,0x15,0x00,0x29,0x24,0x16,0x00,
+		0x2a,0x25,0x16,0x00,0x2b,0x25,0x16,0x00,0x2c,0x26,0x16,0x00,0x2d,0x27,0x17,0x00,0x2d,0x27,0x17,0x00,0x2f,0x28,0x18,0x00,
+		0x2f,0x28,0x18,0x00,0x2f,0x28,0x18,0x00,0x30,0x29,0x18,0x00,0x2f,0x29,0x19,0x00,0x31,0x2a,0x1a,0x00,0x31,0x2a,0x1a,0x00,
+		0x31,0x2a,0x1b,0x00,0x31,0x2a,0x1b,0x00,0x31,0x2a,0x1c,0x00,0x31,0x2b,0x1d,0x00,0x31,0x2b,0x1e,0x00,0x30,0x2a,0x1e,0x00,
+		0x2f,0x2a,0x1e,0x00,0x2e,0x29,0x1e,0x00,0x2c,0x27,0x1d,0x00,0x29,0x25,0x1b,0x00,0x28,0x23,0x1a,0x00,0x25,0x20,0x19,0x00,
+		0x22,0x1e,0x16,0x00,0x1e,0x1b,0x14,0x00,0x1b,0x18,0x12,0x00,0x19,0x16,0x10,0x00,0x16,0x13,0x0d,0x00,0x14,0x11,0x0c,0x00,
+		0x11,0x0e,0x0b,0x00,0x0f,0x0d,0x09,0x00,0x0e,0x0c,0x08,0x00,0x0c,0x0b,0x08,0x00,0x0a,0x09,0x06,0x00,0x09,0x08,0x05,0x00,
+		0x08,0x07,0x05,0x00,0x07,0x07,0x04,0x00,0x07,0x06,0x05,0x00,0x06,0x06,0x04,0x00,0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,
+		0x04,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x10,0x10,0x10,0x00,
+		0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,
+		0x06,0x06,0x04,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x05,0x00,0x08,0x08,0x06,0x00,0x09,0x09,0x07,0x00,0x0b,0x0a,0x08,0x00,
+		0x0c,0x0b,0x09,0x00,0x0d,0x0c,0x09,0x00,0x0e,0x0d,0x0a,0x00,0x10,0x0e,0x0a,0x00,0x11,0x10,0x0b,0x00,0x13,0x12,0x0d,0x00,
+		0x14,0x13,0x0d,0x00,0x16,0x14,0x0e,0x00,0x17,0x15,0x0f,0x00,0x19,0x17,0x0f,0x00,0x1a,0x18,0x10,0x00,0x1c,0x1a,0x11,0x00,
+		0x1e,0x1b,0x11,0x00,0x20,0x1d,0x12,0x00,0x22,0x1f,0x13,0x00,0x24,0x20,0x14,0x00,0x26,0x22,0x15,0x00,0x27,0x23,0x15,0x00,
+		0x29,0x24,0x16,0x00,0x2b,0x26,0x17,0x00,0x2c,0x27,0x17,0x00,0x2e,0x28,0x18,0x00,0x2f,0x29,0x18,0x00,0x30,0x29,0x18,0x00,
+		0x31,0x2b,0x19,0x00,0x32,0x2b,0x19,0x00,0x33,0x2c,0x19,0x00,0x33,0x2b,0x19,0x00,0x34,0x2c,0x1a,0x00,0x34,0x2d,0x1b,0x00,
+		0x35,0x2d,0x1b,0x00,0x37,0x2f,0x1d,0x00,0x37,0x30,0x1e,0x00,0x39,0x31,0x1f,0x00,0x3a,0x32,0x21,0x00,0x3a,0x33,0x22,0x00,
+		0x3c,0x34,0x24,0x00,0x3d,0x35,0x26,0x00,0x3b,0x34,0x26,0x00,0x3b,0x34,0x27,0x00,0x3b,0x34,0x27,0x00,0x3a,0x34,0x28,0x00,
+		0x38,0x32,0x26,0x00,0x35,0x2f,0x25,0x00,0x32,0x2d,0x23,0x00,0x2f,0x2a,0x21,0x00,0x2b,0x27,0x1e,0x00,0x27,0x23,0x1b,0x00,
+		0x23,0x1f,0x18,0x00,0x20,0x1c,0x15,0x00,0x1c,0x19,0x13,0x00,0x19,0x16,0x10,0x00,0x16,0x13,0x0e,0x00,0x13,0x10,0x0c,0x00,
+		0x11,0x0f,0x0a,0x00,0x0e,0x0d,0x09,0x00,0x0d,0x0b,0x08,0x00,0x0b,0x0a,0x06,0x00,0x0a,0x09,0x06,0x00,0x09,0x08,0x06,0x00,
+		0x08,0x07,0x05,0x00,0x07,0x06,0x04,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x04,0x04,0x03,0x00,
+		0x04,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x0f,0x0f,0x0f,0x00,0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x06,0x00,
+		0x09,0x09,0x07,0x00,0x0a,0x09,0x07,0x00,0x0b,0x0a,0x08,0x00,0x0c,0x0c,0x09,0x00,0x0e,0x0d,0x0a,0x00,0x0f,0x0e,0x0a,0x00,
+		0x11,0x10,0x0c,0x00,0x12,0x11,0x0c,0x00,0x14,0x13,0x0d,0x00,0x15,0x14,0x0e,0x00,0x17,0x15,0x0f,0x00,0x19,0x17,0x10,0x00,
+		0x1a,0x18,0x10,0x00,0x1c,0x1a,0x11,0x00,0x1e,0x1b,0x12,0x00,0x20,0x1d,0x13,0x00,0x22,0x1f,0x14,0x00,0x24,0x20,0x14,0x00,
+		0x26,0x22,0x15,0x00,0x28,0x24,0x16,0x00,0x2a,0x26,0x17,0x00,0x2c,0x27,0x18,0x00,0x2e,0x29,0x18,0x00,0x2f,0x29,0x19,0x00,
+		0x31,0x2b,0x19,0x00,0x32,0x2c,0x19,0x00,0x33,0x2c,0x1a,0x00,0x35,0x2d,0x1a,0x00,0x36,0x2f,0x1b,0x00,0x37,0x2f,0x1b,0x00,
+		0x38,0x2f,0x1b,0x00,0x39,0x31,0x1d,0x00,0x3a,0x31,0x1d,0x00,0x3c,0x33,0x1f,0x00,0x3d,0x34,0x20,0x00,0x3e,0x35,0x21,0x00,
+		0x40,0x37,0x23,0x00,0x42,0x39,0x26,0x00,0x44,0x3b,0x28,0x00,0x46,0x3d,0x2b,0x00,0x48,0x3f,0x2d,0x00,0x49,0x41,0x30,0x00,
+		0x4a,0x42,0x32,0x00,0x4b,0x43,0x33,0x00,0x4a,0x42,0x34,0x00,0x48,0x41,0x33,0x00,0x46,0x3f,0x32,0x00,0x44,0x3d,0x31,0x00,
+		0x40,0x3a,0x2f,0x00,0x3b,0x36,0x2c,0x00,0x36,0x31,0x27,0x00,0x32,0x2d,0x24,0x00,0x2d,0x29,0x20,0x00,0x27,0x24,0x1b,0x00,
+		0x25,0x21,0x1a,0x00,0x1f,0x1c,0x15,0x00,0x1a,0x18,0x12,0x00,0x19,0x16,0x10,0x00,0x15,0x12,0x0d,0x00,0x13,0x10,0x0c,0x00,
+		0x10,0x0e,0x0a,0x00,0x0d,0x0c,0x09,0x00,0x0d,0x0b,0x08,0x00,0x0b,0x09,0x07,0x00,0x09,0x09,0x06,0x00,0x09,0x08,0x06,0x00,
+		0x07,0x07,0x05,0x00,0x07,0x06,0x05,0x00,0x06,0x06,0x04,0x00,0x05,0x05,0x03,0x00,0x05,0x04,0x03,0x00,0x04,0x03,0x03,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0e,0x0e,0x0e,0x00,0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x03,0x00,0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x04,0x00,
+		0x07,0x07,0x05,0x00,0x07,0x07,0x06,0x00,0x08,0x08,0x06,0x00,0x09,0x09,0x07,0x00,0x0b,0x0a,0x08,0x00,0x0c,0x0b,0x09,0x00,
+		0x0d,0x0c,0x09,0x00,0x0f,0x0e,0x0b,0x00,0x10,0x0f,0x0b,0x00,0x11,0x10,0x0c,0x00,0x13,0x12,0x0d,0x00,0x15,0x14,0x0e,0x00,
+		0x16,0x15,0x0f,0x00,0x18,0x16,0x10,0x00,0x1a,0x18,0x11,0x00,0x1c,0x1a,0x12,0x00,0x1e,0x1c,0x13,0x00,0x20,0x1d,0x13,0x00,
+		0x22,0x1f,0x14,0x00,0x24,0x21,0x15,0x00,0x26,0x22,0x16,0x00,0x28,0x24,0x17,0x00,0x2a,0x26,0x17,0x00,0x2c,0x27,0x19,0x00,
+		0x2e,0x29,0x19,0x00,0x30,0x2b,0x19,0x00,0x32,0x2c,0x1a,0x00,0x33,0x2d,0x1a,0x00,0x35,0x2e,0x1b,0x00,0x37,0x30,0x1c,0x00,
+		0x38,0x31,0x1c,0x00,0x3a,0x32,0x1c,0x00,0x3b,0x33,0x1d,0x00,0x3d,0x35,0x1f,0x00,0x3e,0x35,0x1f,0x00,0x40,0x37,0x20,0x00,
+		0x41,0x38,0x21,0x00,0x44,0x3a,0x23,0x00,0x46,0x3c,0x25,0x00,0x48,0x3e,0x28,0x00,0x4b,0x41,0x2b,0x00,0x4d,0x44,0x2e,0x00,
+		0x51,0x47,0x32,0x00,0x53,0x4a,0x35,0x00,0x56,0x4c,0x39,0x00,0x58,0x4f,0x3c,0x00,0x5a,0x51,0x3f,0x00,0x5a,0x51,0x40,0x00,
+		0x5a,0x52,0x41,0x00,0x59,0x51,0x41,0x00,0x57,0x50,0x41,0x00,0x54,0x4c,0x3f,0x00,0x50,0x49,0x3c,0x00,0x4b,0x45,0x39,0x00,
+		0x46,0x40,0x34,0x00,0x40,0x3b,0x30,0x00,0x3a,0x35,0x2b,0x00,0x33,0x2e,0x25,0x00,0x2e,0x29,0x21,0x00,0x28,0x24,0x1d,0x00,
+		0x23,0x1f,0x19,0x00,0x1f,0x1c,0x15,0x00,0x1a,0x17,0x12,0x00,0x17,0x14,0x0f,0x00,0x14,0x11,0x0d,0x00,0x11,0x0f,0x0b,0x00,
+		0x0f,0x0d,0x09,0x00,0x0d,0x0c,0x08,0x00,0x0c,0x0b,0x08,0x00,0x0a,0x09,0x06,0x00,0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,
+		0x07,0x06,0x05,0x00,0x06,0x06,0x04,0x00,0x06,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x04,0x04,0x03,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0d,0x0d,0x0d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,0x07,0x07,0x05,0x00,0x08,0x07,0x06,0x00,0x09,0x09,0x07,0x00,
+		0x0a,0x09,0x08,0x00,0x0b,0x0a,0x08,0x00,0x0c,0x0c,0x09,0x00,0x0e,0x0d,0x0a,0x00,0x0f,0x0e,0x0b,0x00,0x11,0x10,0x0c,0x00,
+		0x12,0x11,0x0d,0x00,0x14,0x13,0x0e,0x00,0x16,0x15,0x0f,0x00,0x18,0x16,0x10,0x00,0x19,0x17,0x10,0x00,0x1b,0x19,0x11,0x00,
+		0x1d,0x1b,0x12,0x00,0x1f,0x1d,0x13,0x00,0x21,0x1e,0x14,0x00,0x24,0x21,0x16,0x00,0x26,0x23,0x17,0x00,0x28,0x25,0x18,0x00,
+		0x2a,0x26,0x18,0x00,0x2c,0x28,0x19,0x00,0x2f,0x2a,0x1a,0x00,0x31,0x2c,0x1b,0x00,0x32,0x2c,0x1b,0x00,0x34,0x2e,0x1c,0x00,
+		0x36,0x30,0x1c,0x00,0x38,0x31,0x1d,0x00,0x3b,0x33,0x1e,0x00,0x3c,0x34,0x1e,0x00,0x3e,0x35,0x1f,0x00,0x40,0x37,0x1f,0x00,
+		0x41,0x38,0x20,0x00,0x44,0x3a,0x22,0x00,0x46,0x3c,0x23,0x00,0x48,0x3e,0x25,0x00,0x4a,0x40,0x27,0x00,0x4d,0x42,0x2a,0x00,
+		0x51,0x46,0x2d,0x00,0x53,0x48,0x30,0x00,0x57,0x4c,0x34,0x00,0x5c,0x51,0x39,0x00,0x5f,0x54,0x3d,0x00,0x62,0x57,0x41,0x00,
+		0x66,0x5c,0x46,0x00,0x68,0x5e,0x49,0x00,0x6a,0x60,0x4c,0x00,0x6b,0x62,0x4e,0x00,0x6b,0x62,0x50,0x00,0x6b,0x62,0x50,0x00,
+		0x69,0x60,0x50,0x00,0x65,0x5d,0x4e,0x00,0x61,0x5a,0x4b,0x00,0x5c,0x55,0x47,0x00,0x56,0x50,0x43,0x00,0x50,0x49,0x3d,0x00,
+		0x48,0x42,0x38,0x00,0x41,0x3c,0x32,0x00,0x39,0x35,0x2b,0x00,0x33,0x2e,0x26,0x00,0x2b,0x28,0x20,0x00,0x27,0x23,0x1c,0x00,
+		0x22,0x1e,0x18,0x00,0x1d,0x1a,0x14,0x00,0x18,0x16,0x10,0x00,0x16,0x14,0x0f,0x00,0x12,0x10,0x0c,0x00,0x10,0x0f,0x0b,0x00,
+		0x0d,0x0d,0x09,0x00,0x0d,0x0b,0x08,0x00,0x0b,0x0a,0x08,0x00,0x09,0x09,0x07,0x00,0x09,0x08,0x06,0x00,0x07,0x07,0x05,0x00,
+		0x07,0x06,0x05,0x00,0x06,0x06,0x04,0x00,0x05,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,
+		0x03,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
+		0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
+		0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+		0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x04,0x04,0x04,0x00,0x0c,0x0c,0x0c,0x00,0x1a,0x1a,0x19,0x00,0x24,0x24,0x23,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,
+		0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,
+		0x07,0x06,0x06,0x00,0x08,0x07,0x06,0x00,0x09,0x08,0x07,0x00,0x0a,0x0a,0x08,0x00,0x0c,0x0b,0x09,0x00,0x0d,0x0c,0x0a,0x00,
+		0x0e,0x0d,0x0b,0x00,0x10,0x0f,0x0c,0x00,0x12,0x11,0x0d,0x00,0x13,0x12,0x0e,0x00,0x15,0x14,0x0f,0x00,0x17,0x15,0x10,0x00,
+		0x19,0x17,0x11,0x00,0x1a,0x18,0x11,0x00,0x1c,0x1a,0x12,0x00,0x1f,0x1d,0x14,0x00,0x21,0x1e,0x15,0x00,0x23,0x20,0x16,0x00,
+		0x25,0x22,0x16,0x00,0x28,0x24,0x18,0x00,0x2a,0x26,0x19,0x00,0x2c,0x28,0x19,0x00,0x2f,0x2a,0x1b,0x00,0x31,0x2c,0x1c,0x00,
+		0x33,0x2d,0x1c,0x00,0x35,0x2f,0x1d,0x00,0x37,0x30,0x1d,0x00,0x39,0x32,0x1e,0x00,0x3b,0x34,0x1e,0x00,0x3e,0x36,0x20,0x00,
+		0x40,0x37,0x20,0x00,0x41,0x39,0x21,0x00,0x44,0x3b,0x22,0x00,0x46,0x3c,0x23,0x00,0x49,0x3f,0x25,0x00,0x4b,0x41,0x26,0x00,
+		0x4e,0x43,0x28,0x00,0x51,0x46,0x2b,0x00,0x54,0x48,0x2d,0x00,0x58,0x4c,0x31,0x00,0x5c,0x51,0x36,0x00,0x60,0x54,0x3a,0x00,
+		0x65,0x59,0x3f,0x00,0x69,0x5d,0x44,0x00,0x6e,0x62,0x49,0x00,0x72,0x66,0x4e,0x00,0x77,0x6b,0x53,0x00,0x7a,0x6e,0x57,0x00,
+		0x7b,0x70,0x5a,0x00,0x7d,0x73,0x5d,0x00,0x7d,0x73,0x5f,0x00,0x7c,0x72,0x5f,0x00,0x7b,0x71,0x5f,0x00,0x78,0x6f,0x5d,0x00,
+		0x73,0x6b,0x5a,0x00,0x6e,0x66,0x57,0x00,0x68,0x61,0x53,0x00,0x60,0x59,0x4c,0x00,0x58,0x52,0x45,0x00,0x50,0x4a,0x3f,0x00,
+		0x48,0x43,0x38,0x00,0x40,0x3b,0x31,0x00,0x38,0x34,0x2a,0x00,0x31,0x2e,0x25,0x00,0x2a,0x26,0x1f,0x00,0x25,0x22,0x1b,0x00,
+		0x1f,0x1c,0x15,0x00,0x1b,0x18,0x13,0x00,0x17,0x15,0x10,0x00,0x14,0x12,0x0e,0x00,0x11,0x10,0x0c,0x00,0x0e,0x0d,0x0a,0x00,
+		0x0d,0x0c,0x09,0x00,0x0b,0x0b,0x08,0x00,0x0a,0x09,0x06,0x00,0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x07,0x07,0x05,0x00,
+		0x06,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x04,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x04,0x04,0x03,0x00,0x0c,0x0c,0x0b,0x00,0x19,0x19,0x18,0x00,0x22,0x22,0x21,0x00,
+		0x26,0x26,0x25,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,0x27,0x27,0x26,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,
+		0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x26,0x26,0x25,0x00,0x25,0x25,0x24,0x00,0x26,0x26,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x25,0x25,0x24,0x00,0x24,0x24,0x23,0x00,
+		0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,
+		0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,0x07,0x06,0x06,0x00,0x08,0x08,0x07,0x00,0x09,0x09,0x07,0x00,
+		0x0b,0x0a,0x08,0x00,0x0c,0x0b,0x09,0x00,0x0d,0x0c,0x0a,0x00,0x0f,0x0e,0x0b,0x00,0x11,0x10,0x0d,0x00,0x12,0x11,0x0d,0x00,
+		0x14,0x13,0x0e,0x00,0x15,0x14,0x10,0x00,0x18,0x16,0x11,0x00,0x19,0x18,0x12,0x00,0x1c,0x1a,0x13,0x00,0x1e,0x1c,0x14,0x00,
+		0x20,0x1d,0x15,0x00,0x22,0x1f,0x16,0x00,0x25,0x22,0x17,0x00,0x27,0x23,0x18,0x00,0x29,0x26,0x19,0x00,0x2c,0x28,0x1a,0x00,
+		0x2e,0x2a,0x1b,0x00,0x31,0x2c,0x1c,0x00,0x33,0x2e,0x1d,0x00,0x35,0x30,0x1e,0x00,0x37,0x31,0x1e,0x00,0x3a,0x33,0x1f,0x00,
+		0x3c,0x35,0x20,0x00,0x3f,0x37,0x21,0x00,0x41,0x39,0x21,0x00,0x43,0x3b,0x23,0x00,0x46,0x3d,0x24,0x00,0x48,0x3e,0x24,0x00,
+		0x4b,0x41,0x26,0x00,0x4e,0x43,0x28,0x00,0x50,0x45,0x29,0x00,0x54,0x49,0x2c,0x00,0x57,0x4b,0x2e,0x00,0x5b,0x4f,0x32,0x00,
+		0x5f,0x53,0x36,0x00,0x64,0x58,0x3a,0x00,0x69,0x5c,0x3f,0x00,0x6e,0x61,0x44,0x00,0x73,0x67,0x4a,0x00,0x78,0x6b,0x4f,0x00,
+		0x7e,0x71,0x56,0x00,0x82,0x75,0x5b,0x00,0x86,0x7a,0x5f,0x00,0x8a,0x7d,0x64,0x00,0x8c,0x81,0x68,0x00,0x8d,0x81,0x6a,0x00,
+		0x8e,0x83,0x6c,0x00,0x8d,0x82,0x6d,0x00,0x8c,0x81,0x6d,0x00,0x88,0x7f,0x6c,0x00,0x84,0x7b,0x68,0x00,0x7f,0x76,0x65,0x00,
+		0x78,0x70,0x60,0x00,0x71,0x69,0x5a,0x00,0x6a,0x62,0x54,0x00,0x61,0x5a,0x4d,0x00,0x58,0x52,0x45,0x00,0x4f,0x49,0x3e,0x00,
+		0x45,0x40,0x36,0x00,0x3e,0x39,0x30,0x00,0x35,0x31,0x29,0x00,0x2f,0x2c,0x24,0x00,0x29,0x25,0x1e,0x00,0x22,0x1f,0x19,0x00,
+		0x1e,0x1b,0x15,0x00,0x19,0x17,0x12,0x00,0x16,0x14,0x10,0x00,0x13,0x12,0x0d,0x00,0x11,0x10,0x0c,0x00,0x0d,0x0d,0x09,0x00,
+		0x0c,0x0b,0x09,0x00,0x0b,0x0a,0x08,0x00,0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x07,0x06,0x05,0x00,0x06,0x06,0x04,0x00,
+		0x06,0x05,0x04,0x00,0x05,0x05,0x04,0x00,0x04,0x04,0x03,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x02,0x02,0x01,0x00,0x04,0x04,0x03,0x00,0x0b,0x0b,0x0a,0x00,
+		0x18,0x18,0x17,0x00,0x22,0x22,0x21,0x00,0x26,0x26,0x25,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,
+		0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x27,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,
+		0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,
+		0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,
+		0x28,0x27,0x26,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,
+		0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,
+		0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,
+		0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x27,0x26,0x25,0x00,0x26,0x25,0x25,0x00,
+		0x26,0x25,0x25,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,
+		0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,
+		0x25,0x25,0x24,0x00,0x25,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,
+		0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x05,0x04,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x06,0x05,0x00,
+		0x07,0x06,0x06,0x00,0x08,0x08,0x07,0x00,0x09,0x09,0x08,0x00,0x0b,0x0a,0x09,0x00,0x0c,0x0b,0x0a,0x00,0x0e,0x0d,0x0b,0x00,
+		0x0f,0x0e,0x0c,0x00,0x11,0x10,0x0d,0x00,0x13,0x12,0x0f,0x00,0x15,0x14,0x0f,0x00,0x17,0x15,0x11,0x00,0x19,0x17,0x12,0x00,
+		0x1a,0x19,0x13,0x00,0x1d,0x1a,0x14,0x00,0x1f,0x1c,0x15,0x00,0x21,0x1e,0x16,0x00,0x24,0x21,0x18,0x00,0x26,0x23,0x18,0x00,
+		0x29,0x25,0x1a,0x00,0x2a,0x27,0x1a,0x00,0x2d,0x29,0x1c,0x00,0x2f,0x2b,0x1c,0x00,0x32,0x2d,0x1d,0x00,0x35,0x30,0x1e,0x00,
+		0x37,0x31,0x1f,0x00,0x3a,0x34,0x20,0x00,0x3c,0x36,0x20,0x00,0x3f,0x37,0x22,0x00,0x41,0x39,0x22,0x00,0x44,0x3b,0x23,0x00,
+		0x46,0x3e,0x24,0x00,0x4a,0x40,0x26,0x00,0x4c,0x42,0x27,0x00,0x4f,0x45,0x28,0x00,0x52,0x47,0x2a,0x00,0x55,0x4a,0x2c,0x00,
+		0x59,0x4d,0x2f,0x00,0x5d,0x50,0x32,0x00,0x62,0x55,0x35,0x00,0x66,0x59,0x3a,0x00,0x6c,0x5f,0x3f,0x00,0x71,0x63,0x44,0x00,
+		0x76,0x69,0x4a,0x00,0x7c,0x6e,0x4f,0x00,0x83,0x74,0x56,0x00,0x88,0x79,0x5c,0x00,0x8d,0x7f,0x62,0x00,0x92,0x84,0x66,0x00,
+		0x95,0x88,0x6b,0x00,0x99,0x8b,0x70,0x00,0x9c,0x8e,0x74,0x00,0x9d,0x90,0x76,0x00,0x9d,0x90,0x78,0x00,0x9c,0x91,0x79,0x00,
+		0x9a,0x8f,0x79,0x00,0x99,0x8d,0x78,0x00,0x94,0x8a,0x76,0x00,0x8f,0x85,0x72,0x00,0x89,0x7f,0x6e,0x00,0x81,0x79,0x68,0x00,
+		0x79,0x72,0x62,0x00,0x72,0x6b,0x5c,0x00,0x68,0x61,0x54,0x00,0x5e,0x59,0x4c,0x00,0x55,0x4f,0x44,0x00,0x4d,0x47,0x3d,0x00,
+		0x42,0x3e,0x34,0x00,0x3a,0x36,0x2e,0x00,0x34,0x30,0x28,0x00,0x2c,0x29,0x22,0x00,0x26,0x23,0x1d,0x00,0x20,0x1e,0x18,0x00,
+		0x1c,0x1a,0x14,0x00,0x19,0x17,0x12,0x00,0x15,0x14,0x0f,0x00,0x11,0x10,0x0d,0x00,0x0f,0x0e,0x0b,0x00,0x0c,0x0b,0x09,0x00,
+		0x0b,0x0b,0x08,0x00,0x09,0x09,0x07,0x00,0x08,0x08,0x06,0x00,0x07,0x07,0x05,0x00,0x06,0x06,0x05,0x00,0x06,0x05,0x04,0x00,
+		0x05,0x05,0x04,0x00,0x04,0x04,0x03,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x01,0x02,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x04,0x04,0x03,0x00,0x0a,0x0a,0x09,0x00,0x15,0x15,0x14,0x00,0x20,0x20,0x1f,0x00,0x26,0x26,0x25,0x00,0x27,0x27,0x26,0x00,
+		0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,
+		0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,
+		0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,
+		0x28,0x28,0x26,0x00,0x27,0x27,0x25,0x00,0x28,0x28,0x26,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,
+		0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,
+		0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x25,0x00,
+		0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x27,0x26,0x25,0x00,0x28,0x27,0x25,0x00,0x27,0x26,0x25,0x00,
+		0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,
+		0x26,0x26,0x24,0x00,0x26,0x26,0x24,0x00,0x26,0x26,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x25,0x24,0x00,0x25,0x24,0x23,0x00,
+		0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x24,0x24,0x23,0x00,
+		0x23,0x23,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,
+		0x05,0x04,0x04,0x00,0x05,0x05,0x04,0x00,0x06,0x05,0x05,0x00,0x07,0x06,0x06,0x00,0x09,0x08,0x07,0x00,0x0a,0x09,0x08,0x00,
+		0x0b,0x0a,0x09,0x00,0x0c,0x0c,0x0a,0x00,0x0e,0x0d,0x0b,0x00,0x10,0x0e,0x0c,0x00,0x12,0x10,0x0d,0x00,0x14,0x12,0x0f,0x00,
+		0x15,0x14,0x10,0x00,0x18,0x15,0x12,0x00,0x19,0x17,0x12,0x00,0x1c,0x19,0x14,0x00,0x1e,0x1c,0x15,0x00,0x1f,0x1d,0x16,0x00,
+		0x22,0x20,0x18,0x00,0x25,0x22,0x18,0x00,0x28,0x24,0x1a,0x00,0x2a,0x26,0x1b,0x00,0x2c,0x29,0x1c,0x00,0x2f,0x2b,0x1d,0x00,
+		0x32,0x2d,0x1e,0x00,0x34,0x2f,0x1f,0x00,0x37,0x31,0x20,0x00,0x39,0x33,0x21,0x00,0x3c,0x36,0x21,0x00,0x3f,0x38,0x23,0x00,
+		0x41,0x3a,0x24,0x00,0x44,0x3c,0x24,0x00,0x46,0x3e,0x25,0x00,0x49,0x40,0x26,0x00,0x4d,0x43,0x28,0x00,0x50,0x46,0x2a,0x00,
+		0x53,0x48,0x2b,0x00,0x56,0x4b,0x2d,0x00,0x5a,0x4f,0x30,0x00,0x5f,0x52,0x32,0x00,0x64,0x57,0x37,0x00,0x69,0x5b,0x3a,0x00,
+		0x6d,0x60,0x3e,0x00,0x74,0x66,0x44,0x00,0x79,0x6b,0x49,0x00,0x7f,0x70,0x4e,0x00,0x86,0x76,0x55,0x00,0x8a,0x7b,0x5a,0x00,
+		0x90,0x81,0x61,0x00,0x95,0x86,0x66,0x00,0x9b,0x8c,0x6c,0x00,0xa0,0x91,0x72,0x00,0xa3,0x94,0x76,0x00,0xa6,0x97,0x7a,0x00,
+		0xa8,0x99,0x7d,0x00,0xa9,0x9b,0x80,0x00,0xa9,0x9c,0x81,0x00,0xa8,0x9b,0x82,0x00,0xa7,0x9b,0x83,0x00,0xa5,0x99,0x82,0x00,
+		0xa1,0x96,0x80,0x00,0x9c,0x92,0x7e,0x00,0x98,0x8e,0x7a,0x00,0x91,0x88,0x76,0x00,0x8a,0x81,0x70,0x00,0x82,0x7a,0x69,0x00,
+		0x78,0x70,0x62,0x00,0x6f,0x68,0x5a,0x00,0x65,0x5f,0x52,0x00,0x5c,0x57,0x4b,0x00,0x51,0x4d,0x42,0x00,0x49,0x44,0x3b,0x00,
+		0x3f,0x3c,0x33,0x00,0x38,0x34,0x2c,0x00,0x30,0x2d,0x26,0x00,0x2a,0x28,0x21,0x00,0x24,0x21,0x1b,0x00,0x1e,0x1c,0x17,0x00,
+		0x19,0x18,0x13,0x00,0x17,0x16,0x11,0x00,0x13,0x12,0x0e,0x00,0x10,0x0f,0x0c,0x00,0x0e,0x0d,0x0a,0x00,0x0b,0x0b,0x08,0x00,
+		0x0a,0x0a,0x08,0x00,0x08,0x08,0x06,0x00,0x07,0x07,0x05,0x00,0x06,0x06,0x05,0x00,0x06,0x06,0x04,0x00,0x04,0x04,0x03,0x00,
+		0x04,0x04,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x03,0x02,0x01,0x00,0x08,0x07,0x06,0x00,0x13,0x12,0x11,0x00,0x1f,0x1e,0x1d,0x00,
+		0x26,0x25,0x24,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,0x28,0x27,0x26,0x00,
+		0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x28,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x29,0x28,0x26,0x00,
+		0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,
+		0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,
+		0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,0x28,0x27,0x25,0x00,
+		0x28,0x27,0x25,0x00,0x27,0x26,0x25,0x00,0x28,0x27,0x25,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,
+		0x27,0x26,0x25,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,0x27,0x26,0x24,0x00,
+		0x27,0x26,0x24,0x00,0x26,0x26,0x24,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x23,0x00,0x25,0x25,0x23,0x00,0x25,0x25,0x23,0x00,
+		0x25,0x25,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x24,0x24,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x0f,0x0f,0x0f,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x04,0x04,0x00,0x06,0x05,0x05,0x00,
+		0x07,0x06,0x06,0x00,0x08,0x07,0x07,0x00,0x09,0x09,0x08,0x00,0x0b,0x0a,0x09,0x00,0x0c,0x0c,0x0b,0x00,0x0e,0x0d,0x0b,0x00,
+		0x0f,0x0e,0x0d,0x00,0x12,0x10,0x0e,0x00,0x14,0x12,0x0f,0x00,0x15,0x14,0x11,0x00,0x18,0x16,0x12,0x00,0x19,0x17,0x13,0x00,
+		0x1c,0x19,0x14,0x00,0x1f,0x1c,0x16,0x00,0x20,0x1e,0x17,0x00,0x24,0x21,0x19,0x00,0x25,0x22,0x1a,0x00,0x29,0x25,0x1c,0x00,
+		0x2b,0x28,0x1d,0x00,0x2d,0x2a,0x1d,0x00,0x31,0x2d,0x1f,0x00,0x33,0x2e,0x20,0x00,0x36,0x31,0x21,0x00,0x38,0x33,0x22,0x00,
+		0x3b,0x35,0x22,0x00,0x3e,0x38,0x23,0x00,0x41,0x3a,0x24,0x00,0x44,0x3c,0x25,0x00,0x46,0x3e,0x26,0x00,0x4a,0x41,0x28,0x00,
+		0x4d,0x44,0x29,0x00,0x4f,0x46,0x2a,0x00,0x53,0x48,0x2c,0x00,0x57,0x4c,0x2e,0x00,0x5b,0x4f,0x31,0x00,0x60,0x53,0x34,0x00,
+		0x64,0x58,0x37,0x00,0x6a,0x5c,0x3b,0x00,0x6f,0x61,0x3f,0x00,0x74,0x66,0x43,0x00,0x7b,0x6c,0x49,0x00,0x81,0x71,0x4e,0x00,
+		0x86,0x77,0x54,0x00,0x8c,0x7d,0x59,0x00,0x93,0x83,0x5f,0x00,0x98,0x89,0x65,0x00,0x9e,0x8e,0x6b,0x00,0xa3,0x93,0x70,0x00,
+		0xa8,0x97,0x76,0x00,0xab,0x9b,0x7a,0x00,0xae,0x9f,0x7e,0x00,0xb1,0xa1,0x81,0x00,0xb2,0xa3,0x84,0x00,0xb2,0xa4,0x86,0x00,
+		0xb3,0xa5,0x88,0x00,0xb2,0xa4,0x89,0x00,0xb1,0xa4,0x8a,0x00,0xaf,0xa2,0x89,0x00,0xac,0xa0,0x88,0x00,0xa9,0x9d,0x87,0x00,
+		0xa4,0x99,0x84,0x00,0x9f,0x94,0x80,0x00,0x97,0x8e,0x7c,0x00,0x90,0x87,0x75,0x00,0x87,0x7f,0x6f,0x00,0x7f,0x78,0x69,0x00,
+		0x76,0x6f,0x61,0x00,0x6c,0x66,0x59,0x00,0x62,0x5d,0x51,0x00,0x58,0x53,0x49,0x00,0x4e,0x4b,0x40,0x00,0x46,0x42,0x39,0x00,
+		0x3c,0x39,0x31,0x00,0x34,0x32,0x2b,0x00,0x2d,0x2b,0x24,0x00,0x27,0x25,0x1f,0x00,0x22,0x20,0x1b,0x00,0x1c,0x1b,0x16,0x00,
+		0x17,0x16,0x12,0x00,0x14,0x13,0x0f,0x00,0x11,0x11,0x0e,0x00,0x0f,0x0e,0x0c,0x00,0x0b,0x0b,0x09,0x00,0x0a,0x0a,0x08,0x00,
+		0x09,0x09,0x07,0x00,0x07,0x07,0x05,0x00,0x06,0x06,0x05,0x00,0x05,0x05,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x01,0x01,0x02,0x00,0x01,0x01,0x02,0x00,
+		0x01,0x01,0x02,0x00,0x01,0x01,0x02,0x00,0x01,0x01,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x04,0x03,0x01,0x00,0x07,0x06,0x04,0x00,
+		0x10,0x0f,0x0d,0x00,0x1d,0x1c,0x1a,0x00,0x26,0x25,0x23,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x28,0x28,0x25,0x00,
+		0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,
+		0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,
+		0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x28,0x28,0x25,0x00,0x27,0x27,0x24,0x00,
+		0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x25,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,
+		0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x27,0x27,0x24,0x00,0x26,0x26,0x23,0x00,
+		0x26,0x26,0x23,0x00,0x26,0x25,0x24,0x00,0x26,0x25,0x23,0x00,0x26,0x26,0x23,0x00,0x26,0x25,0x23,0x00,0x26,0x25,0x23,0x00,
+		0x25,0x25,0x23,0x00,0x25,0x24,0x23,0x00,0x24,0x23,0x22,0x00,0x24,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,
+		0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x07,0x07,0x07,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x03,0x03,0x00,0x05,0x04,0x04,0x00,0x06,0x05,0x05,0x00,0x07,0x06,0x06,0x00,0x08,0x07,0x07,0x00,0x09,0x09,0x08,0x00,
+		0x0b,0x0a,0x09,0x00,0x0c,0x0c,0x0b,0x00,0x0f,0x0d,0x0c,0x00,0x0f,0x0e,0x0d,0x00,0x12,0x10,0x0e,0x00,0x14,0x12,0x10,0x00,
+		0x16,0x14,0x11,0x00,0x19,0x16,0x13,0x00,0x1a,0x18,0x14,0x00,0x1d,0x1a,0x15,0x00,0x1f,0x1d,0x17,0x00,0x21,0x1f,0x18,0x00,
+		0x25,0x21,0x1a,0x00,0x28,0x24,0x1c,0x00,0x2a,0x26,0x1c,0x00,0x2d,0x29,0x1e,0x00,0x2f,0x2b,0x1f,0x00,0x32,0x2d,0x20,0x00,
+		0x35,0x30,0x21,0x00,0x38,0x32,0x22,0x00,0x3a,0x34,0x23,0x00,0x3d,0x37,0x24,0x00,0x40,0x3a,0x26,0x00,0x43,0x3b,0x26,0x00,
+		0x46,0x3e,0x27,0x00,0x49,0x41,0x29,0x00,0x4c,0x43,0x2a,0x00,0x50,0x47,0x2c,0x00,0x53,0x49,0x2d,0x00,0x57,0x4d,0x2f,0x00,
+		0x5b,0x51,0x32,0x00,0x60,0x54,0x34,0x00,0x64,0x59,0x37,0x00,0x6a,0x5d,0x3b,0x00,0x6f,0x62,0x3f,0x00,0x75,0x68,0x44,0x00,
+		0x7b,0x6d,0x48,0x00,0x81,0x72,0x4d,0x00,0x87,0x78,0x52,0x00,0x8d,0x7e,0x58,0x00,0x94,0x83,0x5e,0x00,0x9a,0x89,0x63,0x00,
+		0x9f,0x8e,0x68,0x00,0xa5,0x94,0x6e,0x00,0xa9,0x98,0x73,0x00,0xae,0x9c,0x78,0x00,0xb1,0xa0,0x7c,0x00,0xb4,0xa3,0x80,0x00,
+		0xb7,0xa6,0x83,0x00,0xb9,0xa8,0x86,0x00,0xba,0xa9,0x88,0x00,0xba,0xaa,0x8a,0x00,0xb9,0xaa,0x8c,0x00,0xb9,0xab,0x8d,0x00,
+		0xb8,0xaa,0x8d,0x00,0xb6,0xa9,0x8d,0x00,0xb3,0xa7,0x8d,0x00,0xb1,0xa5,0x8c,0x00,0xad,0xa1,0x8a,0x00,0xa8,0x9d,0x87,0x00,
+		0xa2,0x98,0x84,0x00,0x9c,0x93,0x80,0x00,0x95,0x8c,0x7b,0x00,0x8d,0x85,0x75,0x00,0x84,0x7e,0x6e,0x00,0x7c,0x75,0x67,0x00,
+		0x72,0x6d,0x5f,0x00,0x68,0x63,0x57,0x00,0x5e,0x5a,0x4e,0x00,0x54,0x50,0x46,0x00,0x4a,0x48,0x3e,0x00,0x41,0x3f,0x36,0x00,
+		0x39,0x37,0x2f,0x00,0x31,0x2f,0x28,0x00,0x2a,0x28,0x22,0x00,0x24,0x23,0x1e,0x00,0x1e,0x1d,0x18,0x00,0x19,0x18,0x14,0x00,
+		0x16,0x16,0x12,0x00,0x12,0x12,0x0f,0x00,0x0e,0x0e,0x0c,0x00,0x0c,0x0c,0x0a,0x00,0x0a,0x0a,0x08,0x00,0x09,0x09,0x07,0x00,
+		0x08,0x08,0x07,0x00,0x06,0x06,0x05,0x00,0x05,0x05,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x03,0x00,0x03,0x04,0x03,0x00,
+		0x02,0x03,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x03,0x02,0x01,0x00,0x03,0x02,0x01,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x06,0x05,0x03,0x00,0x0d,0x0c,0x0a,0x00,0x1a,0x19,0x17,0x00,0x26,0x25,0x23,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,0x29,0x28,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,
+		0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,
+		0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,
+		0x2a,0x29,0x26,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,
+		0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,
+		0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,
+		0x29,0x28,0x25,0x00,0x29,0x28,0x25,0x00,0x28,0x27,0x25,0x00,0x29,0x27,0x25,0x00,0x29,0x27,0x25,0x00,0x29,0x27,0x24,0x00,
+		0x29,0x27,0x25,0x00,0x29,0x27,0x24,0x00,0x29,0x27,0x24,0x00,0x28,0x27,0x24,0x00,0x28,0x27,0x24,0x00,0x28,0x27,0x24,0x00,
+		0x27,0x26,0x23,0x00,0x28,0x27,0x24,0x00,0x28,0x27,0x24,0x00,0x27,0x26,0x23,0x00,0x26,0x26,0x23,0x00,0x26,0x26,0x23,0x00,
+		0x26,0x26,0x23,0x00,0x26,0x26,0x23,0x00,0x26,0x26,0x23,0x00,0x26,0x25,0x23,0x00,0x25,0x25,0x23,0x00,0x25,0x25,0x23,0x00,
+		0x24,0x24,0x23,0x00,0x24,0x23,0x22,0x00,0x24,0x23,0x22,0x00,0x24,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,
+		0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x12,0x12,0x12,0x00,0x0c,0x0c,0x0c,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x05,0x04,0x05,0x00,0x06,0x05,0x05,0x00,
+		0x07,0x06,0x06,0x00,0x08,0x07,0x07,0x00,0x09,0x08,0x08,0x00,0x0b,0x09,0x09,0x00,0x0c,0x0b,0x0b,0x00,0x0e,0x0c,0x0c,0x00,
+		0x0f,0x0e,0x0d,0x00,0x12,0x10,0x0f,0x00,0x14,0x12,0x10,0x00,0x15,0x14,0x12,0x00,0x19,0x16,0x13,0x00,0x1a,0x18,0x14,0x00,
+		0x1e,0x1b,0x17,0x00,0x1f,0x1c,0x18,0x00,0x21,0x1e,0x19,0x00,0x26,0x22,0x1b,0x00,0x29,0x24,0x1d,0x00,0x2a,0x27,0x1e,0x00,
+		0x2d,0x29,0x1f,0x00,0x30,0x2c,0x20,0x00,0x32,0x2d,0x22,0x00,0x36,0x30,0x23,0x00,0x39,0x33,0x24,0x00,0x3b,0x35,0x25,0x00,
+		0x3f,0x38,0x26,0x00,0x42,0x3b,0x27,0x00,0x44,0x3d,0x28,0x00,0x49,0x41,0x2b,0x00,0x4b,0x43,0x2b,0x00,0x4f,0x46,0x2c,0x00,
+		0x52,0x4a,0x2e,0x00,0x57,0x4d,0x31,0x00,0x59,0x50,0x32,0x00,0x5f,0x54,0x36,0x00,0x64,0x58,0x38,0x00,0x69,0x5d,0x3b,0x00,
+		0x70,0x63,0x40,0x00,0x74,0x67,0x43,0x00,0x7b,0x6d,0x48,0x00,0x82,0x73,0x4d,0x00,0x88,0x79,0x52,0x00,0x8f,0x7f,0x58,0x00,
+		0x95,0x85,0x5d,0x00,0x9b,0x8a,0x62,0x00,0xa1,0x90,0x68,0x00,0xa6,0x95,0x6d,0x00,0xab,0x99,0x71,0x00,0xb0,0x9e,0x76,0x00,
+		0xb3,0xa1,0x7a,0x00,0xb7,0xa5,0x7e,0x00,0xb9,0xa7,0x82,0x00,0xbc,0xaa,0x84,0x00,0xbe,0xac,0x87,0x00,0xbe,0xac,0x89,0x00,
+		0xbf,0xad,0x8b,0x00,0xbf,0xae,0x8c,0x00,0xbf,0xae,0x8e,0x00,0xbd,0xae,0x8f,0x00,0xbd,0xae,0x90,0x00,0xbb,0xac,0x90,0x00,
+		0xba,0xac,0x90,0x00,0xb7,0xaa,0x90,0x00,0xb4,0xa8,0x8f,0x00,0xb1,0xa5,0x8d,0x00,0xac,0xa2,0x8b,0x00,0xa7,0x9d,0x88,0x00,
+		0xa1,0x98,0x85,0x00,0x9a,0x92,0x80,0x00,0x92,0x8b,0x7a,0x00,0x8a,0x84,0x74,0x00,0x82,0x7c,0x6d,0x00,0x78,0x74,0x66,0x00,
+		0x6e,0x6a,0x5e,0x00,0x64,0x60,0x55,0x00,0x59,0x56,0x4c,0x00,0x50,0x4e,0x44,0x00,0x47,0x45,0x3c,0x00,0x3e,0x3c,0x34,0x00,
+		0x35,0x34,0x2d,0x00,0x2e,0x2c,0x26,0x00,0x27,0x27,0x21,0x00,0x22,0x21,0x1d,0x00,0x1c,0x1c,0x18,0x00,0x17,0x16,0x13,0x00,
+		0x13,0x13,0x10,0x00,0x10,0x10,0x0e,0x00,0x0d,0x0d,0x0b,0x00,0x0b,0x0b,0x09,0x00,0x09,0x09,0x07,0x00,0x08,0x08,0x07,0x00,
+		0x06,0x06,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x04,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x02,0x00,0x01,0x01,0x02,0x00,0x01,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x01,0x00,
+		0x02,0x02,0x01,0x00,0x02,0x02,0x01,0x00,0x03,0x02,0x01,0x00,0x03,0x02,0x01,0x00,0x03,0x03,0x01,0x00,0x04,0x03,0x01,0x00,
+		0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x05,0x03,0x00,0x00,0x05,0x04,0x00,0x00,0x07,0x06,0x02,0x00,0x0e,0x0d,0x09,0x00,0x1a,0x19,0x15,0x00,
+		0x24,0x24,0x21,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,
+		0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x29,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,
+		0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,
+		0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2c,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2b,0x29,0x25,0x00,0x2a,0x29,0x25,0x00,
+		0x2a,0x29,0x25,0x00,0x2a,0x29,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,
+		0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x25,0x00,
+		0x2a,0x29,0x25,0x00,0x2a,0x29,0x25,0x00,0x2a,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,
+		0x2a,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2a,0x29,0x25,0x00,0x2a,0x28,0x25,0x00,0x2a,0x28,0x24,0x00,0x2a,0x28,0x24,0x00,
+		0x2a,0x28,0x24,0x00,0x2a,0x28,0x24,0x00,0x2a,0x28,0x24,0x00,0x2a,0x28,0x24,0x00,0x28,0x28,0x24,0x00,0x28,0x27,0x24,0x00,
+		0x28,0x26,0x24,0x00,0x29,0x27,0x24,0x00,0x28,0x26,0x23,0x00,0x27,0x26,0x23,0x00,0x27,0x26,0x23,0x00,0x27,0x26,0x23,0x00,
+		0x26,0x26,0x23,0x00,0x26,0x26,0x23,0x00,0x25,0x25,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x24,0x23,0x00,0x25,0x25,0x23,0x00,
+		0x24,0x24,0x22,0x00,0x24,0x23,0x22,0x00,0x24,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,
+		0x22,0x22,0x21,0x00,0x22,0x22,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x11,0x11,0x11,0x00,0x0b,0x0b,0x0b,0x00,
+		0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x04,0x05,0x00,0x06,0x05,0x06,0x00,0x07,0x06,0x07,0x00,0x09,0x08,0x08,0x00,
+		0x0a,0x09,0x09,0x00,0x0c,0x0a,0x0a,0x00,0x0e,0x0c,0x0c,0x00,0x0f,0x0e,0x0d,0x00,0x12,0x0f,0x0f,0x00,0x14,0x11,0x10,0x00,
+		0x16,0x13,0x12,0x00,0x19,0x16,0x14,0x00,0x19,0x17,0x15,0x00,0x1d,0x1a,0x17,0x00,0x1f,0x1c,0x18,0x00,0x22,0x1f,0x1b,0x00,
+		0x26,0x22,0x1c,0x00,0x29,0x24,0x1d,0x00,0x2a,0x26,0x1f,0x00,0x2d,0x2a,0x21,0x00,0x32,0x2c,0x22,0x00,0x35,0x2f,0x23,0x00,
+		0x38,0x32,0x25,0x00,0x3a,0x34,0x26,0x00,0x3d,0x37,0x27,0x00,0x40,0x3a,0x28,0x00,0x43,0x3c,0x29,0x00,0x47,0x3f,0x2b,0x00,
+		0x4b,0x43,0x2d,0x00,0x4e,0x46,0x2e,0x00,0x51,0x49,0x30,0x00,0x56,0x4c,0x31,0x00,0x59,0x50,0x34,0x00,0x5e,0x54,0x36,0x00,
+		0x63,0x58,0x39,0x00,0x68,0x5d,0x3c,0x00,0x6f,0x62,0x40,0x00,0x74,0x67,0x44,0x00,0x7b,0x6d,0x48,0x00,0x81,0x73,0x4e,0x00,
+		0x87,0x78,0x52,0x00,0x8e,0x7e,0x57,0x00,0x95,0x85,0x5d,0x00,0x9b,0x8a,0x61,0x00,0xa1,0x90,0x66,0x00,0xa6,0x95,0x6b,0x00,
+		0xab,0x99,0x6f,0x00,0xb0,0x9e,0x74,0x00,0xb5,0xa2,0x78,0x00,0xb8,0xa5,0x7c,0x00,0xbc,0xa8,0x7f,0x00,0xbe,0xab,0x82,0x00,
+		0xc0,0xad,0x84,0x00,0xc1,0xae,0x86,0x00,0xc2,0xaf,0x89,0x00,0xc3,0xb0,0x8b,0x00,0xc7,0xb6,0x94,0x00,0xe0,0xd7,0xc4,0x00,
+		0xfa,0xf8,0xf5,0x00,0xff,0xff,0xff,0x00,0xfa,0xf9,0xf7,0x00,0xe0,0xd8,0xca,0x00,0xc2,0xb5,0x9a,0x00,0xbc,0xae,0x92,0x00,
+		0xb9,0xac,0x92,0x00,0xb7,0xab,0x92,0x00,0xb3,0xa8,0x90,0x00,0xae,0xa4,0x8e,0x00,0xaa,0xa1,0x8c,0x00,0xa4,0x9c,0x88,0x00,
+		0x9e,0x97,0x84,0x00,0x97,0x90,0x7f,0x00,0x8f,0x89,0x79,0x00,0x87,0x81,0x72,0x00,0x7e,0x79,0x6b,0x00,0x74,0x70,0x63,0x00,
+		0x6b,0x67,0x5c,0x00,0x5f,0x5d,0x53,0x00,0x56,0x54,0x4a,0x00,0x4c,0x4b,0x42,0x00,0x42,0x41,0x39,0x00,0x39,0x38,0x32,0x00,
+		0x32,0x31,0x2b,0x00,0x2a,0x2a,0x25,0x00,0x24,0x23,0x1f,0x00,0x1e,0x1e,0x1a,0x00,0x19,0x19,0x16,0x00,0x15,0x15,0x12,0x00,
+		0x11,0x11,0x0f,0x00,0x0e,0x0e,0x0c,0x00,0x0c,0x0c,0x0a,0x00,0x09,0x09,0x07,0x00,0x07,0x08,0x07,0x00,0x07,0x07,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x04,0x03,0x00,0x04,0x04,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x03,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x03,0x00,
+		0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,
+		0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,
+		0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x03,0x03,0x00,
+		0x02,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x02,0x02,0x00,0x03,0x02,0x02,0x00,0x03,0x02,0x02,0x00,0x03,0x02,0x02,0x00,0x04,0x03,0x02,0x00,
+		0x03,0x03,0x01,0x00,0x03,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x01,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x05,0x03,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x07,0x05,0x01,0x00,
+		0x0d,0x0b,0x07,0x00,0x18,0x16,0x12,0x00,0x24,0x23,0x1f,0x00,0x2a,0x28,0x25,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,
+		0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,0x2a,0x29,0x26,0x00,
+		0x2a,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,0x2b,0x29,0x26,0x00,
+		0x2b,0x2a,0x26,0x00,0x2b,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2c,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,
+		0x2d,0x2b,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2d,0x2b,0x26,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,
+		0x2c,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x2a,0x26,0x00,0x2b,0x29,0x25,0x00,
+		0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,0x2c,0x29,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,
+		0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2c,0x2a,0x25,0x00,0x2b,0x29,0x25,0x00,0x2b,0x29,0x25,0x00,
+		0x2b,0x29,0x25,0x00,0x2c,0x29,0x25,0x00,0x2c,0x29,0x24,0x00,0x2b,0x29,0x24,0x00,0x2b,0x29,0x24,0x00,0x2b,0x29,0x24,0x00,
+		0x2b,0x29,0x24,0x00,0x2b,0x29,0x24,0x00,0x2a,0x28,0x24,0x00,0x2a,0x28,0x24,0x00,0x29,0x27,0x24,0x00,0x29,0x27,0x24,0x00,
+		0x29,0x27,0x24,0x00,0x28,0x27,0x23,0x00,0x28,0x26,0x23,0x00,0x28,0x26,0x23,0x00,0x27,0x26,0x23,0x00,0x26,0x25,0x23,0x00,
+		0x25,0x25,0x23,0x00,0x26,0x26,0x23,0x00,0x25,0x25,0x23,0x00,0x25,0x24,0x22,0x00,0x25,0x25,0x22,0x00,0x25,0x24,0x22,0x00,
+		0x24,0x24,0x22,0x00,0x24,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1b,0x1b,0x1b,0x00,0x15,0x15,0x15,0x00,0x0e,0x0e,0x0e,0x00,
+		0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x03,0x04,0x00,0x05,0x04,0x05,0x00,
+		0x06,0x05,0x05,0x00,0x07,0x06,0x06,0x00,0x09,0x08,0x08,0x00,0x0a,0x08,0x09,0x00,0x0b,0x0a,0x0a,0x00,0x0e,0x0b,0x0b,0x00,
+		0x0f,0x0d,0x0d,0x00,0x12,0x0f,0x0f,0x00,0x13,0x11,0x10,0x00,0x15,0x12,0x12,0x00,0x17,0x15,0x14,0x00,0x19,0x16,0x14,0x00,
+		0x1c,0x19,0x16,0x00,0x1f,0x1d,0x1a,0x00,0x24,0x1f,0x1b,0x00,0x26,0x20,0x1d,0x00,0x29,0x24,0x1e,0x00,0x2b,0x26,0x1f,0x00,
+		0x2f,0x2a,0x22,0x00,0x32,0x2d,0x23,0x00,0x35,0x30,0x25,0x00,0x39,0x32,0x26,0x00,0x3c,0x35,0x28,0x00,0x3f,0x38,0x29,0x00,
+		0x42,0x3b,0x2b,0x00,0x45,0x3e,0x2b,0x00,0x49,0x41,0x2d,0x00,0x4c,0x44,0x2f,0x00,0x4f,0x47,0x30,0x00,0x54,0x4b,0x32,0x00,
+		0x58,0x4e,0x34,0x00,0x5d,0x53,0x37,0x00,0x62,0x58,0x3a,0x00,0x67,0x5c,0x3d,0x00,0x6e,0x62,0x42,0x00,0x73,0x66,0x44,0x00,
+		0x79,0x6d,0x49,0x00,0x81,0x73,0x4e,0x00,0x87,0x79,0x52,0x00,0x8e,0x7f,0x58,0x00,0x95,0x85,0x5d,0x00,0x9b,0x8b,0x62,0x00,
+		0xa0,0x8f,0x66,0x00,0xa6,0x95,0x6b,0x00,0xac,0x9a,0x6f,0x00,0xb1,0x9e,0x73,0x00,0xb5,0xa2,0x77,0x00,0xb9,0xa5,0x7b,0x00,
+		0xbc,0xa9,0x7d,0x00,0xbf,0xab,0x80,0x00,0xc1,0xad,0x82,0x00,0xc3,0xaf,0x85,0x00,0xc5,0xb1,0x87,0x00,0xc5,0xb1,0x88,0x00,
+		0xc6,0xb2,0x8a,0x00,0xda,0xce,0xb5,0x00,0xf5,0xf2,0xeb,0x00,0xff,0xff,0xff,0x00,0xff,0xf4,0xd3,0x00,0xff,0xde,0x82,0x00,
+		0xff,0xed,0xca,0x00,0xff,0xff,0xff,0x00,0xf5,0xf3,0xee,0x00,0xd5,0xcd,0xb9,0x00,0xbe,0xb1,0x94,0x00,0xbb,0xae,0x94,0x00,
+		0xb7,0xac,0x93,0x00,0xb5,0xaa,0x92,0x00,0xb1,0xa7,0x91,0x00,0xad,0xa4,0x8e,0x00,0xa8,0xa0,0x8c,0x00,0xa1,0x9a,0x88,0x00,
+		0x9b,0x95,0x84,0x00,0x93,0x8e,0x7e,0x00,0x8b,0x87,0x78,0x00,0x83,0x80,0x72,0x00,0x7a,0x77,0x6b,0x00,0x70,0x6e,0x62,0x00,
+		0x66,0x64,0x5a,0x00,0x5b,0x5a,0x51,0x00,0x51,0x50,0x48,0x00,0x48,0x48,0x40,0x00,0x3e,0x3e,0x38,0x00,0x36,0x36,0x30,0x00,
+		0x2f,0x2f,0x2a,0x00,0x27,0x28,0x23,0x00,0x21,0x22,0x1e,0x00,0x1b,0x1c,0x19,0x00,0x16,0x16,0x14,0x00,0x12,0x13,0x10,0x00,
+		0x0e,0x0f,0x0d,0x00,0x0b,0x0c,0x0a,0x00,0x09,0x0a,0x08,0x00,0x07,0x08,0x07,0x00,0x06,0x07,0x06,0x00,0x05,0x05,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x03,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,0x02,0x02,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x02,0x00,0x03,0x03,0x02,0x00,0x04,0x03,0x02,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x02,0x00,
+		0x04,0x04,0x01,0x00,0x05,0x04,0x01,0x00,0x05,0x04,0x01,0x00,0x05,0x04,0x01,0x00,0x05,0x04,0x01,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x07,0x05,0x01,0x00,0x0c,0x0b,0x06,0x00,0x15,0x14,0x0f,0x00,0x21,0x20,0x1c,0x00,0x29,0x28,0x24,0x00,
+		0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,
+		0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2c,0x2a,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,
+		0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2e,0x2b,0x26,0x00,0x2e,0x2c,0x26,0x00,0x2e,0x2c,0x26,0x00,0x2e,0x2c,0x26,0x00,
+		0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2e,0x2b,0x26,0x00,
+		0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2e,0x2b,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2e,0x2b,0x25,0x00,
+		0x2e,0x2b,0x26,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,
+		0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,
+		0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2d,0x2b,0x25,0x00,0x2e,0x2b,0x25,0x00,0x2e,0x2b,0x25,0x00,
+		0x2e,0x2b,0x25,0x00,0x2d,0x2a,0x25,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x25,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,
+		0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,0x2d,0x2a,0x24,0x00,
+		0x2c,0x2a,0x24,0x00,0x2b,0x2a,0x24,0x00,0x2b,0x28,0x24,0x00,0x2b,0x28,0x24,0x00,0x2a,0x28,0x23,0x00,0x2a,0x28,0x23,0x00,
+		0x29,0x27,0x23,0x00,0x29,0x27,0x24,0x00,0x27,0x27,0x23,0x00,0x27,0x26,0x23,0x00,0x27,0x26,0x23,0x00,0x26,0x25,0x23,0x00,
+		0x26,0x26,0x23,0x00,0x25,0x25,0x23,0x00,0x25,0x25,0x22,0x00,0x25,0x24,0x22,0x00,0x24,0x24,0x22,0x00,0x24,0x24,0x22,0x00,
+		0x23,0x23,0x22,0x00,0x23,0x22,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x21,0x00,0x22,0x22,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1c,0x1c,0x1c,0x00,0x17,0x17,0x17,0x00,
+		0x0f,0x0f,0x0f,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x05,0x04,0x04,0x00,0x06,0x04,0x05,0x00,0x07,0x05,0x06,0x00,0x08,0x06,0x07,0x00,
+		0x09,0x08,0x09,0x00,0x0b,0x09,0x0a,0x00,0x0d,0x0b,0x0b,0x00,0x0e,0x0c,0x0d,0x00,0x11,0x0e,0x0e,0x00,0x12,0x0f,0x0f,0x00,
+		0x14,0x12,0x12,0x00,0x17,0x15,0x14,0x00,0x19,0x15,0x14,0x00,0x1c,0x19,0x17,0x00,0x1f,0x1c,0x1a,0x00,0x22,0x1d,0x1a,0x00,
+		0x25,0x20,0x1c,0x00,0x29,0x24,0x1f,0x00,0x2c,0x26,0x21,0x00,0x2f,0x2a,0x24,0x00,0x33,0x2d,0x25,0x00,0x36,0x30,0x26,0x00,
+		0x39,0x33,0x28,0x00,0x3c,0x35,0x29,0x00,0x3f,0x38,0x2a,0x00,0x43,0x3b,0x2c,0x00,0x46,0x3e,0x2d,0x00,0x4a,0x42,0x2f,0x00,
+		0x4d,0x45,0x31,0x00,0x52,0x49,0x33,0x00,0x56,0x4d,0x35,0x00,0x5b,0x52,0x38,0x00,0x60,0x56,0x3b,0x00,0x65,0x5a,0x3d,0x00,
+		0x6c,0x60,0x41,0x00,0x72,0x66,0x46,0x00,0x78,0x6c,0x4a,0x00,0x7f,0x72,0x4e,0x00,0x85,0x78,0x53,0x00,0x8c,0x7e,0x58,0x00,
+		0x92,0x84,0x5d,0x00,0x9a,0x8a,0x62,0x00,0xa0,0x90,0x66,0x00,0xa6,0x95,0x6a,0x00,0xac,0x9a,0x6f,0x00,0xb0,0x9e,0x73,0x00,
+		0xb6,0xa3,0x77,0x00,0xba,0xa7,0x7a,0x00,0xbd,0xaa,0x7d,0x00,0xbf,0xac,0x7f,0x00,0xc2,0xae,0x81,0x00,0xc4,0xaf,0x83,0x00,
+		0xc6,0xb1,0x84,0x00,0xc6,0xb1,0x85,0x00,0xc7,0xb2,0x87,0x00,0xd5,0xc5,0xa5,0x00,0xef,0xe9,0xdd,0x00,0xff,0xff,0xff,0x00,
+		0xff,0xfa,0xea,0x00,0xff,0xe6,0x9b,0x00,0xff,0xd6,0x5c,0x00,0xff,0xc7,0x2b,0x00,0xff,0xc1,0x47,0x00,0xff,0xd9,0x96,0x00,
+		0xff,0xf7,0xe7,0x00,0xff,0xff,0xff,0x00,0xed,0xe9,0xe1,0x00,0xcc,0xc2,0xad,0x00,0xbb,0xaf,0x94,0x00,0xb9,0xae,0x95,0x00,
+		0xb6,0xac,0x94,0x00,0xb3,0xaa,0x93,0x00,0xaf,0xa7,0x91,0x00,0xaa,0xa3,0x8f,0x00,0xa4,0x9e,0x8c,0x00,0x9e,0x99,0x87,0x00,
+		0x97,0x93,0x83,0x00,0x8f,0x8c,0x7d,0x00,0x87,0x84,0x77,0x00,0x7f,0x7c,0x70,0x00,0x75,0x73,0x68,0x00,0x6b,0x6a,0x60,0x00,
+		0x60,0x60,0x57,0x00,0x57,0x57,0x4f,0x00,0x4c,0x4c,0x45,0x00,0x43,0x43,0x3d,0x00,0x3a,0x3a,0x35,0x00,0x32,0x33,0x2e,0x00,
+		0x29,0x2a,0x26,0x00,0x23,0x24,0x21,0x00,0x1d,0x1e,0x1b,0x00,0x17,0x18,0x15,0x00,0x13,0x14,0x11,0x00,0x0f,0x10,0x0e,0x00,
+		0x0c,0x0c,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x09,0x08,0x00,0x06,0x07,0x06,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x04,0x00,0x03,0x03,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x04,0x03,0x03,0x00,0x04,0x04,0x02,0x00,0x04,0x04,0x02,0x00,
+		0x05,0x04,0x02,0x00,0x05,0x04,0x02,0x00,0x05,0x04,0x02,0x00,0x05,0x04,0x01,0x00,0x05,0x04,0x01,0x00,0x06,0x04,0x01,0x00,
+		0x06,0x05,0x01,0x00,0x06,0x05,0x01,0x00,0x06,0x05,0x01,0x00,0x08,0x07,0x02,0x00,0x0c,0x0a,0x05,0x00,0x14,0x12,0x0d,0x00,
+		0x1f,0x1e,0x19,0x00,0x2a,0x28,0x23,0x00,0x2e,0x2c,0x27,0x00,0x2e,0x2c,0x27,0x00,0x2e,0x2c,0x27,0x00,0x2d,0x2c,0x27,0x00,
+		0x2d,0x2c,0x27,0x00,0x2d,0x2c,0x27,0x00,0x2d,0x2c,0x27,0x00,0x2d,0x2c,0x27,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,
+		0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2d,0x2b,0x26,0x00,0x2e,0x2b,0x26,0x00,
+		0x2e,0x2b,0x26,0x00,0x2e,0x2c,0x26,0x00,0x2e,0x2c,0x26,0x00,0x2f,0x2c,0x26,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,
+		0x2f,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x31,0x2e,0x27,0x00,
+		0x31,0x2f,0x27,0x00,0x31,0x2f,0x27,0x00,0x31,0x2f,0x27,0x00,0x30,0x2e,0x26,0x00,0x30,0x2e,0x26,0x00,0x2f,0x2d,0x25,0x00,
+		0x30,0x2e,0x26,0x00,0x2f,0x2d,0x26,0x00,0x2f,0x2d,0x26,0x00,0x30,0x2e,0x26,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x26,0x00,
+		0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,
+		0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,
+		0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2f,0x2d,0x25,0x00,0x2e,0x2d,0x25,0x00,0x2e,0x2d,0x25,0x00,
+		0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x24,0x00,0x2e,0x2c,0x25,0x00,0x2e,0x2c,0x24,0x00,0x2e,0x2c,0x24,0x00,
+		0x2e,0x2c,0x24,0x00,0x2e,0x2c,0x24,0x00,0x2d,0x2b,0x24,0x00,0x2e,0x2c,0x24,0x00,0x2c,0x2a,0x24,0x00,0x2c,0x2a,0x24,0x00,
+		0x2c,0x2a,0x24,0x00,0x2c,0x29,0x24,0x00,0x2c,0x29,0x23,0x00,0x2b,0x29,0x23,0x00,0x2b,0x28,0x24,0x00,0x29,0x28,0x23,0x00,
+		0x2a,0x28,0x23,0x00,0x28,0x27,0x23,0x00,0x27,0x26,0x23,0x00,0x27,0x26,0x23,0x00,0x26,0x25,0x22,0x00,0x26,0x25,0x22,0x00,
+		0x25,0x25,0x22,0x00,0x25,0x25,0x22,0x00,0x25,0x24,0x22,0x00,0x25,0x25,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x22,0x22,0x00,
+		0x23,0x22,0x21,0x00,0x22,0x22,0x21,0x00,0x22,0x22,0x21,0x00,0x21,0x21,0x20,0x00,0x21,0x21,0x21,0x00,0x1d,0x1d,0x1d,0x00,
+		0x18,0x18,0x18,0x00,0x11,0x11,0x11,0x00,0x0a,0x0a,0x0a,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,
+		0x05,0x04,0x04,0x00,0x06,0x05,0x05,0x00,0x07,0x06,0x07,0x00,0x09,0x07,0x08,0x00,0x0a,0x08,0x09,0x00,0x0c,0x0a,0x0b,0x00,
+		0x0e,0x0c,0x0d,0x00,0x0f,0x0e,0x0f,0x00,0x11,0x0e,0x0f,0x00,0x14,0x12,0x12,0x00,0x16,0x13,0x13,0x00,0x19,0x15,0x15,0x00,
+		0x1b,0x19,0x18,0x00,0x1f,0x1a,0x19,0x00,0x22,0x1d,0x1b,0x00,0x24,0x1f,0x1d,0x00,0x28,0x22,0x1f,0x00,0x2c,0x27,0x23,0x00,
+		0x2f,0x29,0x24,0x00,0x33,0x2c,0x26,0x00,0x35,0x2f,0x27,0x00,0x3a,0x32,0x29,0x00,0x3c,0x34,0x2a,0x00,0x3f,0x38,0x2c,0x00,
+		0x42,0x3b,0x2e,0x00,0x46,0x3f,0x2f,0x00,0x4b,0x42,0x32,0x00,0x50,0x46,0x34,0x00,0x53,0x4a,0x35,0x00,0x58,0x4f,0x38,0x00,
+		0x5d,0x53,0x3b,0x00,0x63,0x59,0x3f,0x00,0x69,0x5e,0x42,0x00,0x70,0x64,0x46,0x00,0x77,0x6a,0x4b,0x00,0x7e,0x71,0x50,0x00,
+		0x85,0x77,0x54,0x00,0x8a,0x7d,0x58,0x00,0x91,0x82,0x5d,0x00,0x99,0x89,0x62,0x00,0x9f,0x8f,0x67,0x00,0xa5,0x95,0x6b,0x00,
+		0xac,0x9b,0x70,0x00,0xb0,0x9f,0x73,0x00,0xb5,0xa3,0x77,0x00,0xb9,0xa6,0x79,0x00,0xbd,0xaa,0x7c,0x00,0xc0,0xad,0x7e,0x00,
+		0xc3,0xaf,0x80,0x00,0xc5,0xb0,0x81,0x00,0xc7,0xb2,0x83,0x00,0xc7,0xb2,0x84,0x00,0xc8,0xb3,0x85,0x00,0xd1,0xbe,0x98,0x00,
+		0xea,0xe1,0xd0,0x00,0xfe,0xfe,0xfd,0x00,0xff,0xfc,0xf5,0x00,0xff,0xed,0xb4,0x00,0xff,0xda,0x69,0x00,0xff,0xd3,0x51,0x00,
+		0xff,0xd5,0x58,0x00,0xff,0xcc,0x3c,0x00,0xff,0xbe,0x43,0x00,0xff,0xbd,0x48,0x00,0xff,0xc7,0x5f,0x00,0xff,0xe4,0xb0,0x00,
+		0xff,0xfc,0xf6,0x00,0xfd,0xfd,0xfc,0x00,0xe2,0xdd,0xd1,0x00,0xc4,0xba,0xa3,0x00,0xb9,0xaf,0x95,0x00,0xb7,0xae,0x95,0x00,
+		0xb4,0xac,0x95,0x00,0xb0,0xa9,0x94,0x00,0xac,0xa6,0x92,0x00,0xa7,0xa2,0x8f,0x00,0xa1,0x9d,0x8c,0x00,0x9a,0x97,0x87,0x00,
+		0x93,0x91,0x83,0x00,0x8c,0x8a,0x7d,0x00,0x83,0x82,0x76,0x00,0x7a,0x79,0x6f,0x00,0x70,0x6f,0x66,0x00,0x65,0x65,0x5d,0x00,
+		0x5c,0x5c,0x55,0x00,0x52,0x52,0x4c,0x00,0x47,0x47,0x42,0x00,0x3f,0x40,0x3a,0x00,0x36,0x37,0x32,0x00,0x2d,0x2e,0x2a,0x00,
+		0x26,0x27,0x24,0x00,0x1f,0x20,0x1d,0x00,0x19,0x1a,0x17,0x00,0x14,0x15,0x13,0x00,0x10,0x11,0x0f,0x00,0x0d,0x0e,0x0c,0x00,
+		0x0a,0x0a,0x09,0x00,0x08,0x09,0x08,0x00,0x06,0x07,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x06,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x05,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x05,0x00,0x04,0x04,0x05,0x00,0x04,0x04,0x05,0x00,
+		0x04,0x04,0x05,0x00,0x04,0x05,0x05,0x00,0x04,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x04,0x00,0x05,0x05,0x04,0x00,
+		0x05,0x05,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x05,0x04,0x00,0x06,0x06,0x03,0x00,0x06,0x06,0x03,0x00,
+		0x07,0x06,0x03,0x00,0x07,0x06,0x03,0x00,0x07,0x06,0x03,0x00,0x08,0x06,0x02,0x00,0x08,0x07,0x02,0x00,0x08,0x07,0x02,0x00,
+		0x0a,0x08,0x03,0x00,0x11,0x0f,0x0a,0x00,0x1b,0x19,0x15,0x00,0x28,0x25,0x20,0x00,0x2e,0x2c,0x26,0x00,0x2f,0x2d,0x27,0x00,
+		0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,
+		0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,
+		0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2d,0x27,0x00,0x2f,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,
+		0x30,0x2e,0x27,0x00,0x30,0x2e,0x27,0x00,0x31,0x2f,0x27,0x00,0x31,0x2f,0x27,0x00,0x31,0x2f,0x27,0x00,0x32,0x2f,0x27,0x00,
+		0x32,0x2f,0x27,0x00,0x32,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,
+		0x33,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,0x32,0x2e,0x27,0x00,0x32,0x2e,0x27,0x00,0x33,0x2f,0x27,0x00,0x33,0x2f,0x27,0x00,
+		0x33,0x2f,0x27,0x00,0x32,0x2e,0x26,0x00,0x31,0x2e,0x26,0x00,0x30,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2d,0x25,0x00,
+		0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,
+		0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,
+		0x31,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2e,0x25,0x00,0x30,0x2d,0x25,0x00,0x30,0x2e,0x25,0x00,
+		0x30,0x2d,0x25,0x00,0x31,0x2d,0x25,0x00,0x31,0x2d,0x24,0x00,0x30,0x2d,0x24,0x00,0x30,0x2d,0x24,0x00,0x30,0x2d,0x24,0x00,
+		0x2f,0x2d,0x24,0x00,0x2f,0x2c,0x24,0x00,0x2f,0x2d,0x24,0x00,0x2e,0x2b,0x24,0x00,0x2d,0x2b,0x24,0x00,0x2d,0x2b,0x23,0x00,
+		0x2c,0x2a,0x23,0x00,0x2c,0x2a,0x23,0x00,0x2c,0x29,0x23,0x00,0x2c,0x29,0x23,0x00,0x2b,0x29,0x23,0x00,0x29,0x27,0x23,0x00,
+		0x29,0x27,0x23,0x00,0x28,0x27,0x23,0x00,0x27,0x26,0x23,0x00,0x27,0x25,0x22,0x00,0x26,0x25,0x23,0x00,0x25,0x25,0x22,0x00,
+		0x25,0x25,0x22,0x00,0x25,0x24,0x22,0x00,0x25,0x25,0x22,0x00,0x23,0x23,0x22,0x00,0x23,0x23,0x22,0x00,0x22,0x21,0x20,0x00,
+		0x1e,0x1e,0x1e,0x00,0x19,0x19,0x18,0x00,0x11,0x11,0x10,0x00,0x0b,0x0b,0x0a,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x05,0x04,0x04,0x00,0x06,0x04,0x05,0x00,0x07,0x05,0x07,0x00,
+		0x08,0x06,0x07,0x00,0x09,0x08,0x09,0x00,0x0b,0x0a,0x0a,0x00,0x0c,0x0b,0x0c,0x00,0x0f,0x0c,0x0e,0x00,0x10,0x0e,0x0e,0x00,
+		0x13,0x0f,0x11,0x00,0x15,0x12,0x12,0x00,0x19,0x15,0x16,0x00,0x1b,0x17,0x17,0x00,0x1d,0x19,0x19,0x00,0x20,0x1b,0x1b,0x00,
+		0x24,0x1f,0x1f,0x00,0x28,0x21,0x1f,0x00,0x2c,0x26,0x23,0x00,0x2e,0x27,0x24,0x00,0x33,0x2b,0x26,0x00,0x36,0x2f,0x29,0x00,
+		0x38,0x30,0x29,0x00,0x3c,0x34,0x2b,0x00,0x3f,0x38,0x2e,0x00,0x44,0x3b,0x30,0x00,0x46,0x3e,0x31,0x00,0x4b,0x41,0x33,0x00,
+		0x50,0x46,0x36,0x00,0x55,0x4b,0x39,0x00,0x5b,0x50,0x3c,0x00,0x5f,0x54,0x3e,0x00,0x66,0x5b,0x42,0x00,0x6c,0x61,0x46,0x00,
+		0x73,0x67,0x4b,0x00,0x79,0x6e,0x4f,0x00,0x81,0x74,0x54,0x00,0x87,0x7b,0x59,0x00,0x90,0x82,0x5f,0x00,0x97,0x88,0x63,0x00,
+		0x9d,0x8e,0x68,0x00,0xa4,0x94,0x6c,0x00,0xaa,0x9a,0x70,0x00,0xae,0x9d,0x73,0x00,0xb4,0xa2,0x77,0x00,0xb9,0xa7,0x7a,0x00,
+		0xbd,0xaa,0x7c,0x00,0xc0,0xad,0x7f,0x00,0xc3,0xb0,0x80,0x00,0xc5,0xb1,0x81,0x00,0xc7,0xb2,0x83,0x00,0xc8,0xb3,0x83,0x00,
+		0xc9,0xb3,0x84,0x00,0xce,0xb8,0x8b,0x00,0xe3,0xd8,0xbf,0x00,0xf9,0xf7,0xf2,0x00,0xff,0xfe,0xfd,0x00,0xff,0xf3,0xcb,0x00,
+		0xff,0xe1,0x81,0x00,0xff,0xd8,0x5b,0x00,0xff,0xd7,0x5c,0x00,0xff,0xd6,0x5d,0x00,0xff,0xd6,0x5c,0x00,0xff,0xcc,0x3a,0x00,
+		0xff,0xbe,0x45,0x00,0xff,0xc1,0x54,0x00,0xff,0xc0,0x4e,0x00,0xff,0xc0,0x4a,0x00,0xff,0xcf,0x75,0x00,0xff,0xec,0xc9,0x00,
+		0xff,0xff,0xff,0x00,0xf7,0xf6,0xf3,0x00,0xd8,0xd2,0xc2,0x00,0xbb,0xb3,0x9b,0x00,0xb7,0xb0,0x98,0x00,0xb5,0xae,0x97,0x00,
+		0xb1,0xab,0x96,0x00,0xad,0xa8,0x94,0x00,0xa8,0xa5,0x93,0x00,0xa4,0xa1,0x90,0x00,0x9e,0x9b,0x8c,0x00,0x96,0x95,0x87,0x00,
+		0x90,0x8f,0x82,0x00,0x87,0x87,0x7b,0x00,0x7e,0x7e,0x74,0x00,0x75,0x76,0x6c,0x00,0x6c,0x6c,0x64,0x00,0x61,0x62,0x5b,0x00,
+		0x57,0x58,0x51,0x00,0x4c,0x4e,0x49,0x00,0x43,0x44,0x3f,0x00,0x39,0x3a,0x36,0x00,0x31,0x32,0x2f,0x00,0x28,0x29,0x26,0x00,
+		0x20,0x22,0x1f,0x00,0x1a,0x1b,0x19,0x00,0x14,0x15,0x14,0x00,0x10,0x11,0x10,0x00,0x0c,0x0d,0x0c,0x00,0x0b,0x0b,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x08,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,
+		0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,
+		0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,
+		0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,0x07,0x07,0x08,0x00,
+		0x07,0x07,0x08,0x00,0x07,0x08,0x08,0x00,0x07,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x07,0x00,0x08,0x08,0x07,0x00,0x08,0x08,0x07,0x00,0x08,0x08,0x07,0x00,0x08,0x08,0x07,0x00,0x08,0x08,0x07,0x00,
+		0x09,0x08,0x06,0x00,0x09,0x08,0x06,0x00,0x08,0x07,0x05,0x00,0x08,0x08,0x05,0x00,0x09,0x08,0x04,0x00,0x09,0x08,0x04,0x00,
+		0x0a,0x08,0x04,0x00,0x0a,0x08,0x04,0x00,0x0b,0x0a,0x05,0x00,0x10,0x0e,0x08,0x00,0x1a,0x18,0x13,0x00,0x29,0x26,0x21,0x00,
+		0x2f,0x2d,0x27,0x00,0x31,0x2f,0x29,0x00,0x31,0x2f,0x29,0x00,0x31,0x2f,0x29,0x00,0x31,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,
+		0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,
+		0x32,0x2f,0x29,0x00,0x32,0x2f,0x29,0x00,0x33,0x2f,0x29,0x00,0x33,0x2f,0x29,0x00,0x33,0x30,0x29,0x00,0x33,0x30,0x29,0x00,
+		0x33,0x30,0x29,0x00,0x33,0x30,0x29,0x00,0x34,0x30,0x29,0x00,0x34,0x30,0x29,0x00,0x34,0x30,0x29,0x00,0x34,0x31,0x29,0x00,
+		0x34,0x31,0x29,0x00,0x34,0x31,0x29,0x00,0x35,0x32,0x29,0x00,0x35,0x32,0x29,0x00,0x35,0x32,0x29,0x00,0x36,0x32,0x29,0x00,
+		0x36,0x33,0x29,0x00,0x36,0x32,0x29,0x00,0x36,0x32,0x29,0x00,0x36,0x32,0x29,0x00,0x36,0x33,0x29,0x00,0x36,0x33,0x29,0x00,
+		0x35,0x32,0x29,0x00,0x35,0x32,0x29,0x00,0x35,0x31,0x29,0x00,0x35,0x31,0x28,0x00,0x35,0x32,0x29,0x00,0x35,0x32,0x28,0x00,
+		0x34,0x30,0x27,0x00,0x33,0x2f,0x26,0x00,0x33,0x2f,0x26,0x00,0x33,0x2f,0x26,0x00,0x33,0x2f,0x26,0x00,0x32,0x2e,0x25,0x00,
+		0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,
+		0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x31,0x2e,0x25,0x00,0x33,0x2e,0x25,0x00,0x33,0x2f,0x25,0x00,0x32,0x2e,0x25,0x00,
+		0x32,0x2e,0x25,0x00,0x32,0x2e,0x25,0x00,0x32,0x2f,0x25,0x00,0x32,0x2f,0x25,0x00,0x32,0x2f,0x24,0x00,0x32,0x2f,0x25,0x00,
+		0x32,0x2f,0x24,0x00,0x32,0x2f,0x25,0x00,0x31,0x2f,0x24,0x00,0x31,0x2e,0x24,0x00,0x31,0x2d,0x24,0x00,0x31,0x2e,0x24,0x00,
+		0x30,0x2c,0x24,0x00,0x30,0x2c,0x24,0x00,0x2f,0x2c,0x23,0x00,0x2f,0x2c,0x24,0x00,0x2e,0x2c,0x23,0x00,0x2e,0x2b,0x23,0x00,
+		0x2d,0x2b,0x24,0x00,0x2b,0x2a,0x23,0x00,0x2b,0x29,0x23,0x00,0x2b,0x28,0x23,0x00,0x2a,0x28,0x23,0x00,0x29,0x27,0x23,0x00,
+		0x28,0x26,0x22,0x00,0x28,0x26,0x22,0x00,0x27,0x25,0x22,0x00,0x26,0x25,0x22,0x00,0x26,0x25,0x22,0x00,0x25,0x25,0x22,0x00,
+		0x24,0x23,0x21,0x00,0x22,0x22,0x1f,0x00,0x1d,0x1d,0x1b,0x00,0x15,0x14,0x13,0x00,0x0d,0x0c,0x0b,0x00,0x07,0x07,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x02,0x03,0x00,
+		0x04,0x03,0x04,0x00,0x05,0x04,0x04,0x00,0x06,0x05,0x05,0x00,0x07,0x06,0x07,0x00,0x09,0x07,0x08,0x00,0x0a,0x08,0x09,0x00,
+		0x0b,0x0a,0x0b,0x00,0x0e,0x0c,0x0d,0x00,0x0f,0x0c,0x0e,0x00,0x12,0x0f,0x10,0x00,0x14,0x11,0x12,0x00,0x17,0x14,0x15,0x00,
+		0x1a,0x15,0x16,0x00,0x1d,0x17,0x18,0x00,0x20,0x1b,0x1b,0x00,0x23,0x1d,0x1d,0x00,0x27,0x21,0x20,0x00,0x2a,0x23,0x22,0x00,
+		0x2e,0x27,0x25,0x00,0x31,0x29,0x26,0x00,0x35,0x2d,0x29,0x00,0x38,0x2f,0x2a,0x00,0x3c,0x33,0x2d,0x00,0x3f,0x36,0x2e,0x00,
+		0x44,0x3b,0x32,0x00,0x48,0x3d,0x33,0x00,0x4b,0x41,0x34,0x00,0x50,0x45,0x37,0x00,0x55,0x4b,0x3a,0x00,0x5b,0x50,0x3e,0x00,
+		0x61,0x56,0x42,0x00,0x68,0x5c,0x46,0x00,0x6e,0x62,0x4a,0x00,0x77,0x6a,0x50,0x00,0x7e,0x71,0x54,0x00,0x84,0x78,0x5a,0x00,
+		0x8d,0x7f,0x5f,0x00,0x92,0x84,0x64,0x00,0x9c,0x8d,0x69,0x00,0xa2,0x93,0x6d,0x00,0xa8,0x98,0x71,0x00,0xae,0x9e,0x75,0x00,
+		0xb3,0xa2,0x78,0x00,0xb8,0xa6,0x7b,0x00,0xbc,0xaa,0x7d,0x00,0xc0,0xac,0x7f,0x00,0xc3,0xaf,0x81,0x00,0xc6,0xb1,0x82,0x00,
+		0xc7,0xb3,0x83,0x00,0xc9,0xb4,0x84,0x00,0xca,0xb4,0x84,0x00,0xcb,0xb4,0x84,0x00,0xdd,0xcf,0xae,0x00,0xf5,0xf0,0xe7,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xf8,0xe0,0x00,0xff,0xe7,0x96,0x00,0xff,0xdd,0x66,0x00,0xff,0xda,0x61,0x00,0xff,0xda,0x64,0x00,
+		0xff,0xd8,0x61,0x00,0xff,0xd6,0x5c,0x00,0xff,0xd6,0x5b,0x00,0xff,0xcb,0x39,0x00,0xff,0xbd,0x43,0x00,0xff,0xc0,0x50,0x00,
+		0xff,0xc1,0x52,0x00,0xff,0xc2,0x53,0x00,0xff,0xc0,0x4b,0x00,0xff,0xc2,0x50,0x00,0xff,0xd7,0x8c,0x00,0xff,0xf4,0xe0,0x00,
+		0xff,0xff,0xff,0x00,0xef,0xed,0xe7,0x00,0xcc,0xc6,0xb5,0x00,0xb7,0xb1,0x99,0x00,0xb4,0xaf,0x99,0x00,0xb1,0xad,0x99,0x00,
+		0xae,0xab,0x98,0x00,0xaa,0xa8,0x96,0x00,0xa5,0xa3,0x93,0x00,0xa1,0xa0,0x91,0x00,0x9a,0x99,0x8c,0x00,0x94,0x94,0x88,0x00,
+		0x8c,0x8c,0x81,0x00,0x83,0x84,0x7a,0x00,0x79,0x7b,0x72,0x00,0x70,0x71,0x69,0x00,0x65,0x67,0x60,0x00,0x5c,0x5d,0x57,0x00,
+		0x51,0x53,0x4e,0x00,0x48,0x49,0x45,0x00,0x3c,0x3e,0x3a,0x00,0x33,0x34,0x31,0x00,0x2b,0x2d,0x2a,0x00,0x22,0x23,0x21,0x00,
+		0x1c,0x1d,0x1b,0x00,0x15,0x16,0x15,0x00,0x11,0x12,0x11,0x00,0x0e,0x0f,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0c,0x0c,0x00,0x0b,0x0c,0x0c,0x00,
+		0x0b,0x0c,0x0c,0x00,0x0b,0x0c,0x0c,0x00,0x0b,0x0c,0x0c,0x00,0x0b,0x0c,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,
+		0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0c,0x0c,0x00,
+		0x0b,0x0c,0x0c,0x00,0x0b,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0c,0x00,
+		0x0b,0x0b,0x0a,0x00,0x0c,0x0b,0x0a,0x00,0x0c,0x0c,0x0a,0x00,0x0b,0x0a,0x09,0x00,0x0c,0x0b,0x09,0x00,0x0c,0x0b,0x09,0x00,
+		0x0c,0x0b,0x08,0x00,0x0c,0x0a,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0c,0x0b,0x07,0x00,0x0c,0x0b,0x06,0x00,0x10,0x0e,0x09,0x00,
+		0x18,0x16,0x12,0x00,0x27,0x26,0x20,0x00,0x32,0x2f,0x29,0x00,0x34,0x33,0x2c,0x00,0x36,0x34,0x2d,0x00,0x36,0x34,0x2d,0x00,
+		0x36,0x34,0x2d,0x00,0x37,0x34,0x2c,0x00,0x36,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,
+		0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x37,0x34,0x2c,0x00,0x38,0x34,0x2c,0x00,
+		0x37,0x34,0x2b,0x00,0x37,0x34,0x2b,0x00,0x37,0x34,0x2b,0x00,0x37,0x34,0x2b,0x00,0x37,0x34,0x2b,0x00,0x37,0x34,0x2b,0x00,
+		0x38,0x34,0x2b,0x00,0x38,0x34,0x2b,0x00,0x39,0x35,0x2c,0x00,0x3a,0x36,0x2c,0x00,0x3a,0x35,0x2c,0x00,0x3a,0x36,0x2c,0x00,
+		0x3a,0x36,0x2c,0x00,0x3a,0x36,0x2c,0x00,0x3b,0x36,0x2c,0x00,0x3b,0x37,0x2c,0x00,0x3b,0x37,0x2c,0x00,0x3b,0x37,0x2b,0x00,
+		0x3b,0x37,0x2b,0x00,0x3b,0x37,0x2b,0x00,0x3b,0x37,0x2b,0x00,0x3b,0x37,0x2b,0x00,0x3b,0x37,0x2b,0x00,0x3b,0x37,0x2b,0x00,
+		0x3b,0x37,0x2b,0x00,0x39,0x35,0x2a,0x00,0x3a,0x35,0x2a,0x00,0x39,0x34,0x29,0x00,0x38,0x33,0x29,0x00,0x37,0x33,0x28,0x00,
+		0x37,0x33,0x28,0x00,0x35,0x31,0x27,0x00,0x34,0x31,0x26,0x00,0x34,0x31,0x26,0x00,0x33,0x30,0x25,0x00,0x33,0x30,0x25,0x00,
+		0x33,0x30,0x25,0x00,0x33,0x30,0x25,0x00,0x33,0x30,0x25,0x00,0x33,0x30,0x25,0x00,0x33,0x30,0x25,0x00,0x34,0x30,0x25,0x00,
+		0x34,0x30,0x25,0x00,0x34,0x30,0x25,0x00,0x34,0x30,0x25,0x00,0x35,0x31,0x25,0x00,0x34,0x30,0x25,0x00,0x34,0x30,0x25,0x00,
+		0x34,0x30,0x25,0x00,0x34,0x30,0x25,0x00,0x34,0x30,0x24,0x00,0x35,0x31,0x25,0x00,0x34,0x30,0x24,0x00,0x33,0x2f,0x24,0x00,
+		0x33,0x30,0x24,0x00,0x33,0x2f,0x24,0x00,0x33,0x2f,0x24,0x00,0x32,0x2e,0x24,0x00,0x32,0x2e,0x24,0x00,0x31,0x2e,0x24,0x00,
+		0x31,0x2e,0x24,0x00,0x30,0x2d,0x23,0x00,0x2f,0x2c,0x23,0x00,0x30,0x2c,0x23,0x00,0x2e,0x2c,0x23,0x00,0x2e,0x2b,0x23,0x00,
+		0x2c,0x2a,0x23,0x00,0x2b,0x29,0x23,0x00,0x2b,0x29,0x23,0x00,0x2a,0x28,0x23,0x00,0x2a,0x27,0x22,0x00,0x29,0x27,0x23,0x00,
+		0x28,0x26,0x22,0x00,0x27,0x25,0x22,0x00,0x24,0x23,0x20,0x00,0x21,0x20,0x1d,0x00,0x1a,0x19,0x16,0x00,0x10,0x0f,0x0d,0x00,
+		0x09,0x09,0x06,0x00,0x04,0x04,0x03,0x00,0x03,0x02,0x01,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,0x06,0x04,0x05,0x00,
+		0x07,0x05,0x06,0x00,0x08,0x06,0x07,0x00,0x09,0x07,0x09,0x00,0x0b,0x09,0x0a,0x00,0x0c,0x0a,0x0c,0x00,0x0e,0x0c,0x0d,0x00,
+		0x11,0x0e,0x0f,0x00,0x13,0x0f,0x11,0x00,0x15,0x12,0x13,0x00,0x19,0x14,0x16,0x00,0x1b,0x17,0x19,0x00,0x1f,0x19,0x1b,0x00,
+		0x22,0x1c,0x1d,0x00,0x26,0x1f,0x20,0x00,0x2a,0x22,0x23,0x00,0x2d,0x25,0x25,0x00,0x31,0x28,0x27,0x00,0x34,0x2b,0x2a,0x00,
+		0x37,0x2e,0x2b,0x00,0x3c,0x32,0x2e,0x00,0x40,0x35,0x30,0x00,0x43,0x39,0x32,0x00,0x48,0x3d,0x35,0x00,0x4b,0x3f,0x37,0x00,
+		0x50,0x44,0x38,0x00,0x55,0x49,0x3c,0x00,0x5c,0x50,0x40,0x00,0x62,0x56,0x44,0x00,0x69,0x5d,0x49,0x00,0x70,0x63,0x4e,0x00,
+		0x78,0x6c,0x53,0x00,0x80,0x73,0x59,0x00,0x87,0x7b,0x5f,0x00,0x90,0x83,0x64,0x00,0x96,0x88,0x69,0x00,0x9f,0x90,0x6e,0x00,
+		0xa6,0x96,0x72,0x00,0xab,0x9b,0x76,0x00,0xb1,0xa1,0x79,0x00,0xb6,0xa5,0x7d,0x00,0xbb,0xa9,0x7f,0x00,0xbf,0xad,0x81,0x00,
+		0xc2,0xaf,0x82,0x00,0xc5,0xb2,0x84,0x00,0xc7,0xb3,0x84,0x00,0xc9,0xb5,0x84,0x00,0xca,0xb5,0x84,0x00,0xcb,0xb5,0x85,0x00,
+		0xd6,0xc6,0x9f,0x00,0xf0,0xe9,0xda,0x00,0xff,0xff,0xff,0x00,0xff,0xfc,0xee,0x00,0xff,0xee,0xac,0x00,0xff,0xe2,0x75,0x00,
+		0xff,0xde,0x67,0x00,0xff,0xde,0x6c,0x00,0xff,0xdc,0x67,0x00,0xff,0xda,0x64,0x00,0xff,0xd8,0x60,0x00,0xff,0xd6,0x5b,0x00,
+		0xff,0xd5,0x5b,0x00,0xff,0xcb,0x38,0x00,0xff,0xbc,0x41,0x00,0xff,0xbe,0x4e,0x00,0xff,0xc0,0x4f,0x00,0xff,0xc1,0x51,0x00,
+		0xff,0xc2,0x54,0x00,0xff,0xc4,0x54,0x00,0xff,0xc1,0x4c,0x00,0xff,0xc7,0x5f,0x00,0xff,0xe1,0xa8,0x00,0xff,0xfa,0xf1,0x00,
+		0xfd,0xfd,0xfc,0x00,0xe5,0xe3,0xda,0x00,0xc2,0xbf,0xab,0x00,0xb5,0xb1,0x9b,0x00,0xb1,0xaf,0x9b,0x00,0xaf,0xae,0x9b,0x00,
+		0xab,0xaa,0x99,0x00,0xa6,0xa6,0x97,0x00,0xa2,0xa2,0x94,0x00,0x9d,0x9e,0x91,0x00,0x96,0x97,0x8b,0x00,0x8e,0x90,0x85,0x00,
+		0x87,0x89,0x7f,0x00,0x7e,0x80,0x78,0x00,0x75,0x77,0x70,0x00,0x6b,0x6d,0x67,0x00,0x60,0x62,0x5c,0x00,0x56,0x58,0x53,0x00,
+		0x4a,0x4c,0x48,0x00,0x40,0x42,0x3e,0x00,0x36,0x38,0x35,0x00,0x2c,0x2d,0x2b,0x00,0x24,0x25,0x23,0x00,0x1d,0x1e,0x1d,0x00,
+		0x16,0x17,0x16,0x00,0x13,0x14,0x13,0x00,0x10,0x11,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0f,0x0e,0x00,0x0d,0x0e,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x11,0x11,0x00,0x10,0x11,0x11,0x00,0x11,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x13,0x00,0x12,0x12,0x13,0x00,0x12,0x12,0x13,0x00,0x12,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,
+		0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x12,0x00,0x11,0x11,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x11,0x11,0x00,0x12,0x12,0x11,0x00,0x12,0x12,0x11,0x00,0x12,0x12,0x11,0x00,0x12,0x12,0x11,0x00,
+		0x11,0x11,0x0f,0x00,0x11,0x10,0x0e,0x00,0x11,0x10,0x0e,0x00,0x11,0x10,0x0d,0x00,0x10,0x0f,0x0c,0x00,0x10,0x0f,0x0b,0x00,
+		0x11,0x0f,0x0b,0x00,0x13,0x12,0x0d,0x00,0x19,0x17,0x12,0x00,0x26,0x24,0x1e,0x00,0x32,0x31,0x2b,0x00,0x37,0x35,0x2f,0x00,
+		0x38,0x36,0x2f,0x00,0x3a,0x37,0x30,0x00,0x3a,0x38,0x31,0x00,0x3b,0x38,0x30,0x00,0x3d,0x3a,0x31,0x00,0x3d,0x3a,0x31,0x00,
+		0x3e,0x3b,0x32,0x00,0x3f,0x3b,0x32,0x00,0x3f,0x3b,0x32,0x00,0x3f,0x3b,0x32,0x00,0x3f,0x3b,0x31,0x00,0x3e,0x3a,0x30,0x00,
+		0x3e,0x3a,0x30,0x00,0x3d,0x3a,0x2f,0x00,0x3d,0x3a,0x2f,0x00,0x3d,0x3a,0x2f,0x00,0x3d,0x3a,0x2f,0x00,0x3d,0x3a,0x2f,0x00,
+		0x3c,0x39,0x2f,0x00,0x3c,0x39,0x2f,0x00,0x3d,0x3a,0x2f,0x00,0x3e,0x3a,0x2f,0x00,0x3e,0x3a,0x2f,0x00,0x3f,0x3a,0x2f,0x00,
+		0x3f,0x3b,0x2f,0x00,0x3f,0x3a,0x2f,0x00,0x40,0x3b,0x2f,0x00,0x40,0x3b,0x2f,0x00,0x40,0x3c,0x2f,0x00,0x40,0x3c,0x2f,0x00,
+		0x40,0x3c,0x2f,0x00,0x41,0x3c,0x2f,0x00,0x41,0x3c,0x2f,0x00,0x40,0x3d,0x2f,0x00,0x41,0x3d,0x2f,0x00,0x40,0x3d,0x2f,0x00,
+		0x42,0x3d,0x2f,0x00,0x41,0x3c,0x2e,0x00,0x40,0x3c,0x2e,0x00,0x40,0x3c,0x2e,0x00,0x3f,0x3b,0x2e,0x00,0x3f,0x39,0x2d,0x00,
+		0x3e,0x39,0x2c,0x00,0x3d,0x39,0x2b,0x00,0x3b,0x37,0x2a,0x00,0x3c,0x38,0x2b,0x00,0x3a,0x36,0x29,0x00,0x39,0x35,0x28,0x00,
+		0x39,0x33,0x28,0x00,0x37,0x33,0x27,0x00,0x36,0x32,0x26,0x00,0x36,0x32,0x26,0x00,0x35,0x31,0x25,0x00,0x35,0x31,0x25,0x00,
+		0x36,0x32,0x25,0x00,0x36,0x32,0x25,0x00,0x36,0x32,0x25,0x00,0x36,0x32,0x25,0x00,0x36,0x32,0x25,0x00,0x36,0x31,0x25,0x00,
+		0x36,0x32,0x25,0x00,0x36,0x32,0x25,0x00,0x37,0x32,0x25,0x00,0x37,0x32,0x25,0x00,0x37,0x32,0x25,0x00,0x36,0x32,0x24,0x00,
+		0x37,0x32,0x25,0x00,0x37,0x32,0x24,0x00,0x36,0x32,0x24,0x00,0x36,0x32,0x24,0x00,0x36,0x31,0x24,0x00,0x37,0x32,0x24,0x00,
+		0x35,0x31,0x24,0x00,0x35,0x30,0x24,0x00,0x34,0x30,0x24,0x00,0x34,0x30,0x24,0x00,0x33,0x2f,0x24,0x00,0x32,0x2e,0x24,0x00,
+		0x30,0x2d,0x23,0x00,0x30,0x2e,0x23,0x00,0x30,0x2c,0x23,0x00,0x30,0x2c,0x23,0x00,0x2e,0x2b,0x23,0x00,0x2e,0x2b,0x23,0x00,
+		0x2c,0x2a,0x23,0x00,0x2b,0x29,0x23,0x00,0x2b,0x28,0x23,0x00,0x29,0x26,0x21,0x00,0x24,0x22,0x1e,0x00,0x1e,0x1c,0x18,0x00,
+		0x16,0x14,0x11,0x00,0x0d,0x0c,0x09,0x00,0x08,0x07,0x04,0x00,0x04,0x04,0x01,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x05,0x04,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x05,0x06,0x00,0x09,0x06,0x08,0x00,
+		0x0a,0x08,0x09,0x00,0x0c,0x09,0x0c,0x00,0x0d,0x0a,0x0c,0x00,0x0f,0x0c,0x0e,0x00,0x12,0x0e,0x10,0x00,0x14,0x10,0x13,0x00,
+		0x17,0x12,0x14,0x00,0x1a,0x15,0x18,0x00,0x1d,0x17,0x1a,0x00,0x21,0x1a,0x1d,0x00,0x24,0x1d,0x20,0x00,0x28,0x20,0x22,0x00,
+		0x2c,0x23,0x25,0x00,0x30,0x26,0x27,0x00,0x33,0x2a,0x2a,0x00,0x37,0x2d,0x2c,0x00,0x3b,0x30,0x2e,0x00,0x3e,0x33,0x30,0x00,
+		0x43,0x37,0x33,0x00,0x47,0x3b,0x35,0x00,0x4a,0x3f,0x37,0x00,0x4f,0x43,0x3b,0x00,0x54,0x47,0x3d,0x00,0x5a,0x4e,0x41,0x00,
+		0x60,0x52,0x44,0x00,0x68,0x5a,0x4a,0x00,0x70,0x63,0x50,0x00,0x79,0x6b,0x56,0x00,0x81,0x74,0x5c,0x00,0x8a,0x7c,0x63,0x00,
+		0x92,0x84,0x69,0x00,0x9a,0x8b,0x6e,0x00,0xa1,0x92,0x73,0x00,0xa8,0x99,0x78,0x00,0xaf,0x9e,0x7b,0x00,0xb4,0xa3,0x7f,0x00,
+		0xba,0xa9,0x81,0x00,0xbe,0xac,0x83,0x00,0xc1,0xaf,0x84,0x00,0xc4,0xb1,0x85,0x00,0xc6,0xb3,0x86,0x00,0xc9,0xb5,0x86,0x00,
+		0xca,0xb5,0x86,0x00,0xcb,0xb6,0x85,0x00,0xd3,0xc0,0x96,0x00,0xe9,0xe0,0xcb,0x00,0xfd,0xfc,0xfb,0x00,0xff,0xfe,0xf7,0x00,
+		0xff,0xf4,0xc3,0x00,0xff,0xe7,0x84,0x00,0xff,0xe1,0x6d,0x00,0xff,0xe0,0x71,0x00,0xff,0xdf,0x70,0x00,0xff,0xdd,0x6c,0x00,
+		0xff,0xdc,0x67,0x00,0xff,0xda,0x64,0x00,0xff,0xd8,0x5f,0x00,0xff,0xd6,0x5b,0x00,0xff,0xd5,0x5b,0x00,0xff,0xcb,0x38,0x00,
+		0xff,0xbb,0x3f,0x00,0xff,0xbd,0x4d,0x00,0xff,0xbe,0x4d,0x00,0xff,0xc0,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc3,0x53,0x00,
+		0xff,0xc4,0x56,0x00,0xff,0xc3,0x52,0x00,0xff,0xc1,0x4d,0x00,0xff,0xce,0x6e,0x00,0xff,0xea,0xc2,0x00,0xff,0xfe,0xfd,0x00,
+		0xf9,0xf9,0xf7,0x00,0xd9,0xd7,0xcc,0x00,0xba,0xb8,0xa4,0x00,0xb1,0xb0,0x9d,0x00,0xae,0xaf,0x9c,0x00,0xab,0xac,0x9c,0x00,
+		0xa8,0xa9,0x9a,0x00,0xa3,0xa5,0x97,0x00,0x9f,0xa1,0x94,0x00,0x98,0x9b,0x90,0x00,0x91,0x94,0x8a,0x00,0x8a,0x8d,0x84,0x00,
+		0x82,0x85,0x7d,0x00,0x79,0x7c,0x75,0x00,0x6e,0x71,0x6c,0x00,0x64,0x67,0x62,0x00,0x59,0x5c,0x57,0x00,0x4d,0x50,0x4c,0x00,
+		0x43,0x45,0x42,0x00,0x38,0x3a,0x37,0x00,0x2e,0x2f,0x2d,0x00,0x24,0x26,0x24,0x00,0x1d,0x1f,0x1d,0x00,0x1a,0x1b,0x1a,0x00,
+		0x16,0x18,0x17,0x00,0x15,0x16,0x15,0x00,0x14,0x15,0x14,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x19,0x00,0x19,0x19,0x1a,0x00,0x1a,0x1a,0x1b,0x00,0x1b,0x1b,0x1c,0x00,0x1b,0x1b,0x1c,0x00,0x1b,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1c,0x00,0x1b,0x1b,0x1c,0x00,0x1a,0x1a,0x1b,0x00,0x1a,0x1a,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x1a,0x1a,0x00,0x19,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x1a,0x00,
+		0x19,0x19,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x1a,0x00,0x18,0x18,0x19,0x00,0x18,0x18,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x19,0x19,0x00,
+		0x1a,0x1a,0x19,0x00,0x1a,0x1a,0x19,0x00,0x1a,0x1a,0x19,0x00,0x1b,0x1a,0x19,0x00,0x1a,0x19,0x17,0x00,0x19,0x18,0x16,0x00,
+		0x18,0x18,0x15,0x00,0x19,0x18,0x14,0x00,0x19,0x17,0x14,0x00,0x19,0x18,0x13,0x00,0x1d,0x1b,0x17,0x00,0x26,0x25,0x20,0x00,
+		0x33,0x31,0x2b,0x00,0x3a,0x39,0x33,0x00,0x3e,0x3b,0x35,0x00,0x40,0x3d,0x35,0x00,0x40,0x3e,0x36,0x00,0x41,0x3f,0x37,0x00,
+		0x43,0x40,0x37,0x00,0x44,0x41,0x38,0x00,0x45,0x42,0x38,0x00,0x45,0x42,0x38,0x00,0x46,0x43,0x39,0x00,0x46,0x43,0x39,0x00,
+		0x47,0x43,0x39,0x00,0x47,0x43,0x39,0x00,0x47,0x44,0x39,0x00,0x47,0x43,0x37,0x00,0x46,0x42,0x36,0x00,0x46,0x42,0x36,0x00,
+		0x46,0x42,0x36,0x00,0x45,0x41,0x36,0x00,0x45,0x41,0x36,0x00,0x45,0x42,0x36,0x00,0x46,0x42,0x36,0x00,0x46,0x42,0x36,0x00,
+		0x46,0x42,0x36,0x00,0x46,0x42,0x36,0x00,0x46,0x42,0x35,0x00,0x46,0x42,0x35,0x00,0x47,0x43,0x35,0x00,0x47,0x43,0x35,0x00,
+		0x47,0x43,0x35,0x00,0x48,0x44,0x35,0x00,0x48,0x43,0x35,0x00,0x49,0x44,0x35,0x00,0x49,0x44,0x35,0x00,0x49,0x44,0x35,0x00,
+		0x4a,0x45,0x35,0x00,0x4a,0x45,0x35,0x00,0x4a,0x45,0x35,0x00,0x49,0x44,0x35,0x00,0x49,0x44,0x35,0x00,0x49,0x44,0x34,0x00,
+		0x49,0x44,0x35,0x00,0x49,0x44,0x35,0x00,0x48,0x43,0x33,0x00,0x47,0x42,0x33,0x00,0x45,0x41,0x32,0x00,0x45,0x40,0x32,0x00,
+		0x44,0x3f,0x30,0x00,0x42,0x3d,0x2e,0x00,0x3f,0x3b,0x2d,0x00,0x3e,0x39,0x2b,0x00,0x3c,0x37,0x29,0x00,0x3b,0x36,0x28,0x00,
+		0x3a,0x35,0x28,0x00,0x39,0x33,0x26,0x00,0x39,0x33,0x26,0x00,0x38,0x33,0x25,0x00,0x38,0x33,0x25,0x00,0x38,0x33,0x25,0x00,
+		0x39,0x33,0x25,0x00,0x38,0x32,0x25,0x00,0x39,0x33,0x25,0x00,0x38,0x34,0x25,0x00,0x38,0x33,0x25,0x00,0x38,0x33,0x25,0x00,
+		0x39,0x34,0x25,0x00,0x39,0x34,0x25,0x00,0x39,0x33,0x25,0x00,0x38,0x33,0x24,0x00,0x39,0x34,0x25,0x00,0x39,0x34,0x25,0x00,
+		0x38,0x34,0x24,0x00,0x38,0x33,0x24,0x00,0x38,0x34,0x24,0x00,0x38,0x33,0x24,0x00,0x37,0x32,0x24,0x00,0x37,0x32,0x24,0x00,
+		0x37,0x32,0x24,0x00,0x36,0x31,0x24,0x00,0x36,0x31,0x24,0x00,0x34,0x30,0x23,0x00,0x34,0x30,0x24,0x00,0x32,0x2e,0x23,0x00,
+		0x31,0x2d,0x23,0x00,0x30,0x2d,0x23,0x00,0x2f,0x2b,0x23,0x00,0x2e,0x2b,0x23,0x00,0x2d,0x2b,0x23,0x00,0x2a,0x28,0x21,0x00,
+		0x25,0x22,0x1c,0x00,0x1d,0x1a,0x15,0x00,0x15,0x12,0x0d,0x00,0x0d,0x0c,0x06,0x00,0x09,0x07,0x03,0x00,0x05,0x04,0x00,0x00,
+		0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,
+		0x05,0x04,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x05,0x07,0x00,0x09,0x07,0x09,0x00,0x0b,0x08,0x0a,0x00,0x0c,0x0a,0x0b,0x00,
+		0x0e,0x0b,0x0d,0x00,0x10,0x0c,0x0f,0x00,0x13,0x0f,0x11,0x00,0x15,0x11,0x14,0x00,0x18,0x12,0x16,0x00,0x1c,0x16,0x19,0x00,
+		0x1f,0x18,0x1c,0x00,0x23,0x1b,0x1f,0x00,0x27,0x1e,0x22,0x00,0x2a,0x21,0x25,0x00,0x2e,0x25,0x28,0x00,0x32,0x27,0x2a,0x00,
+		0x36,0x2b,0x2c,0x00,0x3a,0x2e,0x2f,0x00,0x3e,0x32,0x31,0x00,0x41,0x35,0x33,0x00,0x45,0x38,0x35,0x00,0x48,0x3c,0x38,0x00,
+		0x4e,0x40,0x3a,0x00,0x52,0x44,0x3e,0x00,0x59,0x4a,0x41,0x00,0x5f,0x50,0x44,0x00,0x67,0x58,0x4b,0x00,0x6f,0x60,0x51,0x00,
+		0x79,0x6a,0x58,0x00,0x81,0x73,0x5f,0x00,0x8b,0x7c,0x65,0x00,0x94,0x84,0x6c,0x00,0x9d,0x8d,0x72,0x00,0xa5,0x95,0x78,0x00,
+		0xab,0x9a,0x7c,0x00,0xb2,0xa0,0x7f,0x00,0xb6,0xa5,0x82,0x00,0xbb,0xaa,0x84,0x00,0xbf,0xad,0x86,0x00,0xc3,0xb1,0x88,0x00,
+		0xc6,0xb2,0x88,0x00,0xc8,0xb4,0x88,0x00,0xc9,0xb4,0x87,0x00,0xcb,0xb6,0x88,0x00,0xce,0xb9,0x8d,0x00,0xe3,0xd6,0xbb,0x00,
+		0xf9,0xf7,0xf1,0x00,0xff,0xff,0xfe,0x00,0xff,0xf8,0xd6,0x00,0xff,0xed,0x99,0x00,0xff,0xe6,0x77,0x00,0xff,0xe4,0x78,0x00,
+		0xff,0xe3,0x78,0x00,0xff,0xe1,0x74,0x00,0xff,0xdf,0x6f,0x00,0xff,0xdd,0x6c,0x00,0xff,0xdc,0x67,0x00,0xff,0xda,0x63,0x00,
+		0xff,0xd8,0x5f,0x00,0xff,0xd6,0x5b,0x00,0xff,0xd5,0x5b,0x00,0xff,0xca,0x38,0x00,0xff,0xb9,0x3d,0x00,0xff,0xbc,0x4b,0x00,
+		0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,0xff,0xc0,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc4,0x56,0x00,
+		0xff,0xc4,0x58,0x00,0xff,0xc4,0x53,0x00,0xff,0xc5,0x55,0x00,0xff,0xd6,0x86,0x00,0xff,0xf2,0xda,0x00,0xff,0xff,0xff,0x00,
+		0xf1,0xf1,0xed,0x00,0xcc,0xcc,0xbf,0x00,0xb2,0xb3,0xa1,0x00,0xae,0xb0,0x9f,0x00,0xab,0xad,0x9e,0x00,0xa8,0xab,0x9d,0x00,
+		0xa4,0xa7,0x9a,0x00,0x9f,0xa3,0x98,0x00,0x9a,0x9e,0x94,0x00,0x94,0x98,0x8f,0x00,0x8d,0x91,0x89,0x00,0x85,0x89,0x81,0x00,
+		0x7c,0x80,0x79,0x00,0x72,0x75,0x70,0x00,0x66,0x69,0x64,0x00,0x5b,0x5e,0x5a,0x00,0x4e,0x51,0x4e,0x00,0x43,0x46,0x43,0x00,
+		0x37,0x3a,0x37,0x00,0x2f,0x31,0x2f,0x00,0x28,0x29,0x28,0x00,0x21,0x22,0x21,0x00,0x1e,0x1f,0x1e,0x00,0x1b,0x1d,0x1c,0x00,
+		0x1c,0x1d,0x1c,0x00,0x1d,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x22,0x22,0x00,0x23,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,
+		0x26,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x24,0x00,0x23,0x23,0x24,0x00,0x23,0x23,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x25,0x00,0x24,0x24,0x25,0x00,0x24,0x24,0x25,0x00,0x24,0x24,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x24,0x00,0x23,0x24,0x24,0x00,0x23,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x20,0x20,0x21,0x00,0x20,0x20,0x21,0x00,0x20,0x20,0x21,0x00,0x20,0x20,0x21,0x00,0x21,0x21,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x23,0x00,
+		0x25,0x25,0x23,0x00,0x25,0x25,0x23,0x00,0x24,0x24,0x22,0x00,0x24,0x23,0x20,0x00,0x23,0x22,0x1f,0x00,0x23,0x22,0x1e,0x00,
+		0x25,0x24,0x1f,0x00,0x2c,0x2a,0x25,0x00,0x35,0x33,0x2f,0x00,0x3f,0x3e,0x38,0x00,0x43,0x41,0x3b,0x00,0x45,0x42,0x3b,0x00,
+		0x46,0x44,0x3c,0x00,0x49,0x45,0x3e,0x00,0x4b,0x47,0x3f,0x00,0x4c,0x4a,0x40,0x00,0x4e,0x4b,0x40,0x00,0x4f,0x4b,0x41,0x00,
+		0x51,0x4c,0x42,0x00,0x51,0x4c,0x41,0x00,0x52,0x4e,0x42,0x00,0x52,0x4e,0x42,0x00,0x53,0x4f,0x41,0x00,0x53,0x4f,0x41,0x00,
+		0x53,0x4f,0x41,0x00,0x52,0x4e,0x40,0x00,0x51,0x4c,0x40,0x00,0x51,0x4c,0x40,0x00,0x51,0x4c,0x3f,0x00,0x51,0x4c,0x3f,0x00,
+		0x50,0x4b,0x3e,0x00,0x50,0x4b,0x3e,0x00,0x50,0x4b,0x3e,0x00,0x51,0x4b,0x3e,0x00,0x51,0x4c,0x3e,0x00,0x51,0x4b,0x3e,0x00,
+		0x51,0x4c,0x3e,0x00,0x51,0x4c,0x3e,0x00,0x52,0x4d,0x3f,0x00,0x53,0x4e,0x3f,0x00,0x53,0x4e,0x3f,0x00,0x54,0x4e,0x3f,0x00,
+		0x54,0x4e,0x3f,0x00,0x54,0x4e,0x3f,0x00,0x55,0x4f,0x3f,0x00,0x55,0x4f,0x3f,0x00,0x55,0x4f,0x3f,0x00,0x55,0x4f,0x3f,0x00,
+		0x55,0x4e,0x3f,0x00,0x55,0x4e,0x3f,0x00,0x55,0x4e,0x3e,0x00,0x54,0x4d,0x3e,0x00,0x53,0x4d,0x3e,0x00,0x53,0x4d,0x3d,0x00,
+		0x52,0x4c,0x3c,0x00,0x51,0x4b,0x3c,0x00,0x50,0x4a,0x39,0x00,0x4e,0x48,0x39,0x00,0x4a,0x44,0x35,0x00,0x49,0x44,0x33,0x00,
+		0x46,0x41,0x31,0x00,0x44,0x3e,0x2e,0x00,0x41,0x3c,0x2c,0x00,0x3f,0x3a,0x2a,0x00,0x3f,0x39,0x29,0x00,0x3d,0x37,0x28,0x00,
+		0x3b,0x35,0x26,0x00,0x3b,0x35,0x26,0x00,0x3a,0x35,0x25,0x00,0x39,0x35,0x25,0x00,0x3a,0x34,0x25,0x00,0x39,0x35,0x25,0x00,
+		0x3b,0x35,0x25,0x00,0x3a,0x35,0x25,0x00,0x3b,0x35,0x25,0x00,0x3b,0x35,0x25,0x00,0x3b,0x35,0x25,0x00,0x3b,0x35,0x25,0x00,
+		0x3c,0x36,0x25,0x00,0x3c,0x36,0x25,0x00,0x3c,0x35,0x25,0x00,0x3b,0x35,0x24,0x00,0x3b,0x35,0x24,0x00,0x3b,0x36,0x24,0x00,
+		0x3b,0x36,0x24,0x00,0x3a,0x34,0x24,0x00,0x3a,0x34,0x24,0x00,0x39,0x33,0x24,0x00,0x38,0x32,0x24,0x00,0x38,0x32,0x24,0x00,
+		0x37,0x32,0x24,0x00,0x36,0x31,0x23,0x00,0x35,0x30,0x23,0x00,0x34,0x30,0x23,0x00,0x34,0x30,0x24,0x00,0x32,0x2e,0x23,0x00,
+		0x30,0x2d,0x23,0x00,0x2c,0x29,0x1f,0x00,0x23,0x1f,0x16,0x00,0x19,0x16,0x0e,0x00,0x12,0x10,0x07,0x00,0x0d,0x0b,0x04,0x00,
+		0x0a,0x07,0x01,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,0x05,0x04,0x05,0x00,0x07,0x05,0x07,0x00,
+		0x08,0x06,0x07,0x00,0x09,0x07,0x09,0x00,0x0a,0x08,0x0a,0x00,0x0c,0x0a,0x0c,0x00,0x0f,0x0b,0x0e,0x00,0x12,0x0e,0x10,0x00,
+		0x14,0x0f,0x13,0x00,0x16,0x11,0x15,0x00,0x1a,0x14,0x18,0x00,0x1d,0x16,0x1a,0x00,0x21,0x19,0x1d,0x00,0x24,0x1c,0x20,0x00,
+		0x28,0x1f,0x23,0x00,0x2c,0x22,0x26,0x00,0x30,0x25,0x29,0x00,0x33,0x28,0x2c,0x00,0x37,0x2b,0x2f,0x00,0x3c,0x2f,0x32,0x00,
+		0x40,0x33,0x34,0x00,0x44,0x36,0x36,0x00,0x47,0x39,0x38,0x00,0x4c,0x3d,0x3b,0x00,0x50,0x41,0x3d,0x00,0x57,0x47,0x41,0x00,
+		0x5d,0x4d,0x45,0x00,0x63,0x54,0x4b,0x00,0x6c,0x5c,0x50,0x00,0x76,0x65,0x58,0x00,0x7f,0x6f,0x5f,0x00,0x88,0x79,0x67,0x00,
+		0x93,0x82,0x6e,0x00,0x9c,0x8b,0x76,0x00,0xa5,0x95,0x7b,0x00,0xac,0x9b,0x80,0x00,0xb5,0xa3,0x85,0x00,0xb8,0xa7,0x86,0x00,
+		0xbe,0xac,0x89,0x00,0xc1,0xae,0x8a,0x00,0xc4,0xb1,0x8b,0x00,0xc7,0xb4,0x8c,0x00,0xc9,0xb5,0x8b,0x00,0xcb,0xb6,0x8b,0x00,
+		0xcc,0xb7,0x8a,0x00,0xdc,0xce,0xad,0x00,0xf4,0xf0,0xe6,0x00,0xff,0xff,0xff,0x00,0xff,0xfb,0xe6,0x00,0xff,0xf2,0xab,0x00,
+		0xff,0xea,0x80,0x00,0xff,0xe7,0x7c,0x00,0xff,0xe7,0x7e,0x00,0xff,0xe5,0x7b,0x00,0xff,0xe3,0x77,0x00,0xff,0xe1,0x73,0x00,
+		0xff,0xdf,0x6e,0x00,0xff,0xdd,0x6b,0x00,0xff,0xdc,0x67,0x00,0xff,0xda,0x63,0x00,0xff,0xd8,0x5f,0x00,0xff,0xd5,0x5a,0x00,
+		0xff,0xd5,0x5a,0x00,0xff,0xca,0x37,0x00,0xff,0xb9,0x3c,0x00,0xff,0xbb,0x49,0x00,0xff,0xbc,0x49,0x00,0xff,0xbd,0x4c,0x00,
+		0xff,0xbf,0x4d,0x00,0xff,0xc0,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc4,0x55,0x00,0xff,0xc5,0x57,0x00,
+		0xff,0xc5,0x58,0x00,0xff,0xc4,0x51,0x00,0xff,0xc8,0x5d,0x00,0xff,0xdf,0x9f,0x00,0xff,0xf8,0xea,0x00,0xff,0xff,0xff,0x00,
+		0xe7,0xe7,0xe1,0x00,0xc0,0xc2,0xb5,0x00,0xad,0xb1,0xa1,0x00,0xab,0xaf,0xa0,0x00,0xa8,0xad,0x9f,0x00,0xa4,0xa9,0x9d,0x00,
+		0xa1,0xa5,0x9b,0x00,0x9c,0xa0,0x96,0x00,0x96,0x9b,0x92,0x00,0x8f,0x94,0x8c,0x00,0x87,0x8c,0x85,0x00,0x7e,0x82,0x7d,0x00,
+		0x73,0x77,0x72,0x00,0x69,0x6d,0x68,0x00,0x5c,0x60,0x5c,0x00,0x50,0x53,0x50,0x00,0x45,0x48,0x45,0x00,0x3b,0x3d,0x3b,0x00,
+		0x32,0x34,0x33,0x00,0x2c,0x2d,0x2c,0x00,0x28,0x29,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x29,0x2a,0x2a,0x00,
+		0x2b,0x2c,0x2c,0x00,0x2e,0x2e,0x2e,0x00,0x30,0x30,0x30,0x00,0x32,0x32,0x33,0x00,0x34,0x34,0x34,0x00,0x35,0x35,0x35,0x00,
+		0x34,0x35,0x35,0x00,0x35,0x36,0x36,0x00,0x35,0x35,0x36,0x00,0x34,0x34,0x35,0x00,0x34,0x35,0x35,0x00,0x33,0x34,0x34,0x00,
+		0x34,0x34,0x34,0x00,0x33,0x33,0x33,0x00,0x33,0x33,0x33,0x00,0x33,0x33,0x33,0x00,0x32,0x32,0x32,0x00,0x31,0x31,0x31,0x00,
+		0x31,0x31,0x31,0x00,0x31,0x31,0x31,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,
+		0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x31,0x00,0x31,0x31,0x31,0x00,
+		0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x31,0x32,0x00,0x31,0x32,0x32,0x00,
+		0x2f,0x30,0x30,0x00,0x2f,0x30,0x30,0x00,0x2f,0x2f,0x2f,0x00,0x2e,0x2e,0x2e,0x00,0x2d,0x2d,0x2d,0x00,0x2d,0x2d,0x2d,0x00,
+		0x2d,0x2d,0x2d,0x00,0x2d,0x2d,0x2d,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x30,0x30,0x30,0x00,0x30,0x30,0x30,0x00,
+		0x31,0x31,0x31,0x00,0x32,0x32,0x32,0x00,0x32,0x32,0x31,0x00,0x32,0x32,0x31,0x00,0x33,0x32,0x31,0x00,0x32,0x32,0x30,0x00,
+		0x32,0x31,0x2f,0x00,0x31,0x30,0x2e,0x00,0x31,0x30,0x2c,0x00,0x34,0x33,0x2f,0x00,0x3e,0x3d,0x38,0x00,0x47,0x46,0x41,0x00,
+		0x4c,0x4b,0x45,0x00,0x4d,0x4b,0x45,0x00,0x4f,0x4c,0x45,0x00,0x50,0x4d,0x45,0x00,0x51,0x4e,0x46,0x00,0x54,0x51,0x48,0x00,
+		0x57,0x53,0x4a,0x00,0x58,0x55,0x4b,0x00,0x5b,0x57,0x4b,0x00,0x5c,0x58,0x4c,0x00,0x5d,0x59,0x4d,0x00,0x5e,0x59,0x4d,0x00,
+		0x5f,0x5b,0x4d,0x00,0x60,0x5b,0x4d,0x00,0x61,0x5c,0x4e,0x00,0x61,0x5c,0x4d,0x00,0x61,0x5c,0x4d,0x00,0x5f,0x5b,0x4c,0x00,
+		0x5f,0x5a,0x4b,0x00,0x5f,0x5a,0x4b,0x00,0x5e,0x59,0x4b,0x00,0x5d,0x58,0x4a,0x00,0x5d,0x58,0x4a,0x00,0x5d,0x57,0x49,0x00,
+		0x5d,0x57,0x49,0x00,0x5d,0x58,0x49,0x00,0x5e,0x58,0x49,0x00,0x5e,0x59,0x49,0x00,0x5e,0x59,0x49,0x00,0x5e,0x59,0x49,0x00,
+		0x5f,0x59,0x49,0x00,0x5f,0x5a,0x49,0x00,0x60,0x5a,0x49,0x00,0x60,0x5a,0x49,0x00,0x61,0x5b,0x49,0x00,0x61,0x5b,0x49,0x00,
+		0x62,0x5b,0x49,0x00,0x61,0x5a,0x48,0x00,0x62,0x5b,0x49,0x00,0x61,0x5a,0x48,0x00,0x61,0x5b,0x48,0x00,0x62,0x5c,0x49,0x00,
+		0x62,0x5c,0x49,0x00,0x62,0x5c,0x49,0x00,0x61,0x5a,0x48,0x00,0x5f,0x59,0x47,0x00,0x5f,0x59,0x46,0x00,0x5d,0x56,0x44,0x00,
+		0x5b,0x55,0x44,0x00,0x59,0x53,0x41,0x00,0x56,0x50,0x3e,0x00,0x52,0x4c,0x3b,0x00,0x4e,0x47,0x37,0x00,0x4a,0x44,0x33,0x00,
+		0x47,0x41,0x30,0x00,0x44,0x3e,0x2d,0x00,0x41,0x3b,0x2a,0x00,0x3f,0x3a,0x28,0x00,0x3f,0x39,0x28,0x00,0x3d,0x37,0x26,0x00,
+		0x3c,0x36,0x25,0x00,0x3c,0x36,0x25,0x00,0x3d,0x37,0x25,0x00,0x3c,0x36,0x25,0x00,0x3d,0x37,0x25,0x00,0x3d,0x36,0x25,0x00,
+		0x3e,0x37,0x25,0x00,0x3e,0x37,0x25,0x00,0x3e,0x37,0x25,0x00,0x3e,0x38,0x25,0x00,0x3e,0x38,0x25,0x00,0x3d,0x38,0x25,0x00,
+		0x3d,0x37,0x24,0x00,0x3d,0x37,0x24,0x00,0x3d,0x37,0x24,0x00,0x3d,0x38,0x25,0x00,0x3d,0x37,0x24,0x00,0x3c,0x36,0x24,0x00,
+		0x3c,0x36,0x24,0x00,0x3c,0x35,0x24,0x00,0x3a,0x35,0x24,0x00,0x3a,0x34,0x24,0x00,0x38,0x33,0x24,0x00,0x37,0x31,0x23,0x00,
+		0x36,0x31,0x23,0x00,0x36,0x30,0x23,0x00,0x34,0x2f,0x22,0x00,0x2e,0x2a,0x1e,0x00,0x23,0x1f,0x13,0x00,0x19,0x14,0x09,0x00,
+		0x12,0x0f,0x04,0x00,0x10,0x0c,0x02,0x00,0x0e,0x0a,0x01,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,
+		0x03,0x02,0x03,0x00,0x05,0x04,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x05,0x07,0x00,0x09,0x06,0x08,0x00,0x09,0x08,0x09,0x00,
+		0x0b,0x09,0x0b,0x00,0x0d,0x0a,0x0d,0x00,0x10,0x0b,0x0f,0x00,0x13,0x0d,0x12,0x00,0x15,0x0f,0x14,0x00,0x18,0x12,0x17,0x00,
+		0x1b,0x14,0x19,0x00,0x1e,0x16,0x1c,0x00,0x22,0x1a,0x20,0x00,0x26,0x1c,0x22,0x00,0x2a,0x1f,0x25,0x00,0x2e,0x22,0x28,0x00,
+		0x32,0x25,0x2b,0x00,0x36,0x29,0x2f,0x00,0x39,0x2c,0x31,0x00,0x3e,0x2f,0x34,0x00,0x42,0x33,0x36,0x00,0x46,0x36,0x39,0x00,
+		0x4a,0x3b,0x3b,0x00,0x4e,0x3f,0x3f,0x00,0x54,0x43,0x41,0x00,0x59,0x48,0x44,0x00,0x61,0x4f,0x49,0x00,0x69,0x57,0x4f,0x00,
+		0x72,0x60,0x56,0x00,0x7b,0x69,0x5d,0x00,0x86,0x75,0x67,0x00,0x91,0x7f,0x6f,0x00,0x9a,0x89,0x76,0x00,0xa4,0x92,0x7d,0x00,
+		0xac,0x9a,0x82,0x00,0xb3,0xa1,0x86,0x00,0xb9,0xa7,0x8a,0x00,0xbf,0xac,0x8d,0x00,0xc2,0xaf,0x8e,0x00,0xc6,0xb2,0x8f,0x00,
+		0xc8,0xb4,0x8e,0x00,0xc8,0xb4,0x8d,0x00,0xcb,0xb6,0x8e,0x00,0xd6,0xc6,0xa3,0x00,0xee,0xe8,0xd9,0x00,0xfe,0xfe,0xfd,0x00,
+		0xff,0xfe,0xf2,0x00,0xff,0xf6,0xbf,0x00,0xff,0xed,0x8e,0x00,0xff,0xeb,0x82,0x00,0xff,0xea,0x85,0x00,0xff,0xe8,0x82,0x00,
+		0xff,0xe7,0x7e,0x00,0xff,0xe5,0x7b,0x00,0xff,0xe3,0x76,0x00,0xff,0xe0,0x73,0x00,0xff,0xdf,0x6e,0x00,0xff,0xdd,0x6b,0x00,
+		0xff,0xdb,0x66,0x00,0xff,0xd9,0x63,0x00,0xff,0xd7,0x5e,0x00,0xff,0xd5,0x5a,0x00,0xff,0xd5,0x5a,0x00,0xff,0xc9,0x37,0x00,
+		0xff,0xb7,0x3a,0x00,0xff,0xb9,0x46,0x00,0xff,0xba,0x47,0x00,0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,
+		0xff,0xc0,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc3,0x55,0x00,0xff,0xc5,0x57,0x00,0xff,0xc6,0x59,0x00,
+		0xff,0xc6,0x59,0x00,0xff,0xc5,0x51,0x00,0xff,0xce,0x6d,0x00,0xff,0xe7,0xb9,0x00,0xff,0xfd,0xfb,0x00,0xfa,0xfa,0xf9,0x00,
+		0xda,0xdc,0xd4,0x00,0xb5,0xba,0xab,0x00,0xaa,0xb0,0xa2,0x00,0xa7,0xae,0xa1,0x00,0xa5,0xab,0x9f,0x00,0xa1,0xa7,0x9c,0x00,
+		0x9c,0xa2,0x9a,0x00,0x97,0x9d,0x95,0x00,0x90,0x96,0x8f,0x00,0x88,0x8d,0x87,0x00,0x7f,0x83,0x7e,0x00,0x75,0x79,0x75,0x00,
+		0x68,0x6c,0x68,0x00,0x5d,0x60,0x5d,0x00,0x51,0x54,0x51,0x00,0x46,0x49,0x46,0x00,0x3f,0x40,0x3f,0x00,0x38,0x3a,0x39,0x00,
+		0x34,0x36,0x35,0x00,0x33,0x34,0x33,0x00,0x34,0x35,0x34,0x00,0x36,0x37,0x36,0x00,0x38,0x39,0x39,0x00,0x3c,0x3d,0x3d,0x00,
+		0x3f,0x40,0x40,0x00,0x42,0x42,0x42,0x00,0x43,0x44,0x44,0x00,0x44,0x44,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x44,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x45,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,
+		0x42,0x42,0x42,0x00,0x41,0x41,0x42,0x00,0x41,0x41,0x42,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,
+		0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,
+		0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,
+		0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x3f,0x3f,0x40,0x00,0x3f,0x40,0x40,0x00,0x3e,0x3f,0x3f,0x00,0x3e,0x3f,0x3f,0x00,
+		0x3d,0x3d,0x3d,0x00,0x3d,0x3d,0x3d,0x00,0x3b,0x3b,0x3c,0x00,0x3b,0x3b,0x3c,0x00,0x3b,0x3c,0x3c,0x00,0x3b,0x3c,0x3c,0x00,
+		0x3c,0x3c,0x3c,0x00,0x3d,0x3d,0x3d,0x00,0x3e,0x3e,0x3e,0x00,0x3f,0x3f,0x3f,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,
+		0x40,0x40,0x3f,0x00,0x41,0x40,0x3f,0x00,0x41,0x41,0x3f,0x00,0x41,0x41,0x3f,0x00,0x41,0x40,0x3e,0x00,0x43,0x42,0x3f,0x00,
+		0x4a,0x49,0x45,0x00,0x53,0x51,0x4e,0x00,0x58,0x57,0x53,0x00,0x58,0x57,0x51,0x00,0x58,0x57,0x51,0x00,0x59,0x57,0x51,0x00,
+		0x5b,0x58,0x51,0x00,0x5c,0x59,0x51,0x00,0x5f,0x5c,0x52,0x00,0x62,0x5e,0x54,0x00,0x64,0x60,0x55,0x00,0x67,0x63,0x57,0x00,
+		0x68,0x64,0x57,0x00,0x6b,0x67,0x59,0x00,0x6c,0x67,0x5a,0x00,0x6d,0x68,0x5a,0x00,0x6e,0x69,0x5b,0x00,0x6f,0x69,0x5b,0x00,
+		0x6f,0x6a,0x5b,0x00,0x6f,0x6a,0x5a,0x00,0x6e,0x69,0x59,0x00,0x6e,0x68,0x59,0x00,0x6e,0x69,0x59,0x00,0x6e,0x68,0x57,0x00,
+		0x6d,0x68,0x57,0x00,0x6d,0x67,0x56,0x00,0x6c,0x66,0x55,0x00,0x6c,0x66,0x55,0x00,0x6c,0x67,0x55,0x00,0x6c,0x66,0x55,0x00,
+		0x6c,0x67,0x55,0x00,0x6d,0x67,0x55,0x00,0x6d,0x67,0x55,0x00,0x6d,0x68,0x56,0x00,0x6e,0x68,0x56,0x00,0x6e,0x68,0x56,0x00,
+		0x6f,0x68,0x56,0x00,0x6f,0x68,0x56,0x00,0x6f,0x68,0x55,0x00,0x6f,0x68,0x55,0x00,0x70,0x69,0x55,0x00,0x6f,0x68,0x54,0x00,
+		0x6f,0x68,0x54,0x00,0x6f,0x68,0x54,0x00,0x70,0x69,0x55,0x00,0x70,0x69,0x55,0x00,0x70,0x69,0x55,0x00,0x6f,0x68,0x54,0x00,
+		0x6d,0x66,0x53,0x00,0x6d,0x66,0x53,0x00,0x6d,0x67,0x52,0x00,0x6c,0x65,0x51,0x00,0x68,0x61,0x4e,0x00,0x66,0x5f,0x4b,0x00,
+		0x60,0x5b,0x48,0x00,0x5c,0x56,0x43,0x00,0x57,0x50,0x3f,0x00,0x53,0x4c,0x39,0x00,0x4d,0x47,0x35,0x00,0x49,0x43,0x30,0x00,
+		0x45,0x3f,0x2d,0x00,0x43,0x3d,0x2a,0x00,0x42,0x3b,0x28,0x00,0x40,0x39,0x27,0x00,0x3e,0x39,0x26,0x00,0x3e,0x37,0x25,0x00,
+		0x3e,0x38,0x25,0x00,0x3e,0x39,0x25,0x00,0x3f,0x38,0x25,0x00,0x3f,0x39,0x25,0x00,0x40,0x39,0x25,0x00,0x40,0x38,0x25,0x00,
+		0x41,0x39,0x25,0x00,0x40,0x39,0x25,0x00,0x41,0x39,0x25,0x00,0x41,0x3a,0x25,0x00,0x41,0x3a,0x25,0x00,0x42,0x3a,0x25,0x00,
+		0x41,0x39,0x24,0x00,0x40,0x38,0x24,0x00,0x40,0x38,0x24,0x00,0x3f,0x37,0x24,0x00,0x3e,0x37,0x24,0x00,0x3e,0x37,0x24,0x00,
+		0x3c,0x37,0x24,0x00,0x3c,0x35,0x24,0x00,0x3b,0x35,0x24,0x00,0x39,0x34,0x23,0x00,0x35,0x30,0x21,0x00,0x2e,0x29,0x1a,0x00,
+		0x23,0x1f,0x0f,0x00,0x1b,0x16,0x06,0x00,0x15,0x10,0x02,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,
+		0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x04,0x05,0x00,
+		0x06,0x04,0x06,0x00,0x07,0x05,0x07,0x00,0x08,0x06,0x08,0x00,0x09,0x07,0x09,0x00,0x0b,0x09,0x0b,0x00,0x0e,0x0a,0x0d,0x00,
+		0x11,0x0c,0x10,0x00,0x13,0x0e,0x12,0x00,0x16,0x10,0x15,0x00,0x19,0x12,0x18,0x00,0x1c,0x14,0x1b,0x00,0x20,0x17,0x1e,0x00,
+		0x24,0x1a,0x21,0x00,0x28,0x1d,0x25,0x00,0x2c,0x20,0x27,0x00,0x2e,0x22,0x29,0x00,0x34,0x26,0x2e,0x00,0x38,0x29,0x31,0x00,
+		0x3c,0x2d,0x34,0x00,0x40,0x30,0x37,0x00,0x44,0x34,0x39,0x00,0x48,0x37,0x3b,0x00,0x4b,0x3b,0x3e,0x00,0x51,0x3f,0x41,0x00,
+		0x56,0x44,0x44,0x00,0x5c,0x4a,0x48,0x00,0x63,0x51,0x4d,0x00,0x6d,0x59,0x55,0x00,0x75,0x62,0x5a,0x00,0x81,0x6f,0x65,0x00,
+		0x8c,0x78,0x6c,0x00,0x96,0x83,0x76,0x00,0xa1,0x8e,0x7e,0x00,0xab,0x97,0x84,0x00,0xb4,0xa1,0x8a,0x00,0xb9,0xa5,0x8d,0x00,
+		0xbf,0xab,0x90,0x00,0xc3,0xaf,0x92,0x00,0xc6,0xb1,0x91,0x00,0xc8,0xb3,0x91,0x00,0xca,0xb5,0x91,0x00,0xd1,0xbf,0x9d,0x00,
+		0xe7,0xdd,0xcb,0x00,0xfd,0xfc,0xfa,0x00,0xff,0xfe,0xfa,0x00,0xff,0xfa,0xd1,0x00,0xff,0xf2,0x9c,0x00,0xff,0xef,0x88,0x00,
+		0xff,0xee,0x8a,0x00,0xff,0xec,0x89,0x00,0xff,0xea,0x85,0x00,0xff,0xe8,0x81,0x00,0xff,0xe7,0x7d,0x00,0xff,0xe4,0x7a,0x00,
+		0xff,0xe3,0x75,0x00,0xff,0xe1,0x72,0x00,0xff,0xdf,0x6e,0x00,0xff,0xdd,0x6b,0x00,0xff,0xdb,0x66,0x00,0xff,0xd9,0x62,0x00,
+		0xff,0xd7,0x5e,0x00,0xff,0xd5,0x59,0x00,0xff,0xd5,0x5a,0x00,0xff,0xc9,0x37,0x00,0xff,0xb6,0x38,0x00,0xff,0xb8,0x45,0x00,
+		0xff,0xb9,0x45,0x00,0xff,0xbb,0x47,0x00,0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbf,0x4d,0x00,0xff,0xc0,0x4f,0x00,
+		0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc4,0x55,0x00,0xff,0xc5,0x57,0x00,0xff,0xc6,0x5a,0x00,0xff,0xc7,0x5b,0x00,
+		0xff,0xc6,0x56,0x00,0xff,0xc6,0x54,0x00,0xff,0xd4,0x80,0x00,0xff,0xef,0xd1,0x00,0xff,0xff,0xff,0x00,0xf4,0xf5,0xf3,0x00,
+		0xcc,0xd0,0xc8,0x00,0xac,0xb3,0xa6,0x00,0xa7,0xae,0xa3,0x00,0xa5,0xac,0xa2,0x00,0xa1,0xa8,0x9e,0x00,0x9e,0xa4,0x9c,0x00,
+		0x98,0x9e,0x96,0x00,0x92,0x98,0x91,0x00,0x89,0x8f,0x89,0x00,0x7e,0x83,0x7e,0x00,0x74,0x78,0x74,0x00,0x69,0x6c,0x69,0x00,
+		0x5e,0x61,0x5e,0x00,0x54,0x57,0x54,0x00,0x4b,0x4e,0x4c,0x00,0x45,0x47,0x46,0x00,0x42,0x44,0x43,0x00,0x41,0x43,0x42,0x00,
+		0x43,0x44,0x44,0x00,0x45,0x46,0x46,0x00,0x49,0x4a,0x4a,0x00,0x4d,0x4e,0x4e,0x00,0x4f,0x50,0x50,0x00,0x52,0x53,0x53,0x00,
+		0x54,0x55,0x55,0x00,0x55,0x55,0x56,0x00,0x55,0x56,0x56,0x00,0x55,0x55,0x56,0x00,0x55,0x56,0x56,0x00,0x55,0x55,0x56,0x00,
+		0x55,0x55,0x56,0x00,0x54,0x54,0x55,0x00,0x53,0x53,0x54,0x00,0x53,0x53,0x54,0x00,0x52,0x52,0x53,0x00,0x51,0x51,0x52,0x00,
+		0x51,0x51,0x52,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,
+		0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,
+		0x50,0x51,0x51,0x00,0x51,0x51,0x51,0x00,0x50,0x50,0x51,0x00,0x50,0x51,0x51,0x00,0x50,0x51,0x51,0x00,0x51,0x51,0x51,0x00,
+		0x4f,0x4f,0x50,0x00,0x4f,0x50,0x50,0x00,0x4e,0x4f,0x50,0x00,0x4d,0x4e,0x4f,0x00,0x4d,0x4d,0x4e,0x00,0x4c,0x4c,0x4d,0x00,
+		0x4b,0x4c,0x4c,0x00,0x4b,0x4c,0x4c,0x00,0x4b,0x4c,0x4c,0x00,0x4b,0x4c,0x4c,0x00,0x4c,0x4d,0x4d,0x00,0x4c,0x4d,0x4d,0x00,
+		0x4e,0x4e,0x4e,0x00,0x4f,0x4f,0x4f,0x00,0x50,0x50,0x50,0x00,0x50,0x50,0x50,0x00,0x51,0x51,0x50,0x00,0x51,0x51,0x50,0x00,
+		0x51,0x51,0x4f,0x00,0x54,0x54,0x51,0x00,0x58,0x57,0x54,0x00,0x60,0x5e,0x5b,0x00,0x68,0x66,0x63,0x00,0x69,0x68,0x63,0x00,
+		0x68,0x66,0x61,0x00,0x67,0x65,0x5f,0x00,0x67,0x64,0x5e,0x00,0x68,0x65,0x5d,0x00,0x68,0x66,0x5d,0x00,0x6b,0x68,0x5e,0x00,
+		0x6d,0x6a,0x5f,0x00,0x70,0x6d,0x61,0x00,0x73,0x6e,0x62,0x00,0x75,0x71,0x64,0x00,0x79,0x74,0x67,0x00,0x7a,0x75,0x67,0x00,
+		0x7b,0x76,0x68,0x00,0x7e,0x78,0x68,0x00,0x7f,0x79,0x68,0x00,0x7f,0x79,0x68,0x00,0x7f,0x79,0x68,0x00,0x7f,0x79,0x68,0x00,
+		0x7f,0x79,0x67,0x00,0x7f,0x79,0x67,0x00,0x7f,0x78,0x66,0x00,0x7f,0x78,0x65,0x00,0x7e,0x77,0x64,0x00,0x7d,0x76,0x63,0x00,
+		0x7c,0x76,0x62,0x00,0x7c,0x75,0x62,0x00,0x7c,0x75,0x62,0x00,0x7c,0x76,0x62,0x00,0x7d,0x76,0x62,0x00,0x7d,0x76,0x62,0x00,
+		0x7d,0x76,0x62,0x00,0x7f,0x77,0x63,0x00,0x7f,0x77,0x63,0x00,0x7f,0x77,0x62,0x00,0x7f,0x78,0x62,0x00,0x7f,0x78,0x62,0x00,
+		0x7f,0x78,0x62,0x00,0x7f,0x78,0x62,0x00,0x7f,0x78,0x62,0x00,0x7f,0x79,0x62,0x00,0x7f,0x79,0x62,0x00,0x7f,0x79,0x62,0x00,
+		0x7f,0x79,0x62,0x00,0x7f,0x79,0x62,0x00,0x7f,0x79,0x62,0x00,0x7f,0x78,0x61,0x00,0x7e,0x77,0x61,0x00,0x7f,0x78,0x62,0x00,
+		0x7c,0x75,0x5f,0x00,0x7a,0x72,0x5e,0x00,0x78,0x70,0x5b,0x00,0x72,0x6b,0x57,0x00,0x6f,0x68,0x53,0x00,0x69,0x61,0x4d,0x00,
+		0x61,0x5b,0x47,0x00,0x5b,0x54,0x3f,0x00,0x55,0x4e,0x3a,0x00,0x4f,0x49,0x34,0x00,0x4a,0x43,0x2f,0x00,0x46,0x3e,0x2c,0x00,
+		0x44,0x3d,0x28,0x00,0x43,0x3c,0x28,0x00,0x41,0x3a,0x26,0x00,0x42,0x3a,0x26,0x00,0x41,0x39,0x25,0x00,0x41,0x39,0x25,0x00,
+		0x42,0x3a,0x25,0x00,0x43,0x3b,0x25,0x00,0x43,0x3a,0x25,0x00,0x43,0x3b,0x25,0x00,0x43,0x3b,0x25,0x00,0x43,0x3b,0x25,0x00,
+		0x44,0x3c,0x25,0x00,0x43,0x3b,0x24,0x00,0x43,0x3b,0x24,0x00,0x43,0x3c,0x25,0x00,0x43,0x3b,0x24,0x00,0x43,0x3b,0x24,0x00,
+		0x42,0x3a,0x24,0x00,0x41,0x3a,0x24,0x00,0x41,0x3a,0x24,0x00,0x40,0x39,0x24,0x00,0x3f,0x37,0x24,0x00,0x3c,0x36,0x22,0x00,
+		0x38,0x32,0x1e,0x00,0x2f,0x28,0x16,0x00,0x25,0x1f,0x0b,0x00,0x1d,0x16,0x04,0x00,0x19,0x13,0x01,0x00,0x17,0x12,0x00,0x00,
+		0x15,0x10,0x00,0x00,0x13,0x0f,0x00,0x00,0x11,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x05,0x07,0x00,
+		0x08,0x07,0x08,0x00,0x0a,0x08,0x0a,0x00,0x0c,0x08,0x0c,0x00,0x0f,0x0a,0x0f,0x00,0x11,0x0c,0x10,0x00,0x14,0x0e,0x13,0x00,
+		0x16,0x0f,0x16,0x00,0x1a,0x12,0x19,0x00,0x1d,0x14,0x1c,0x00,0x21,0x17,0x1f,0x00,0x25,0x1a,0x22,0x00,0x28,0x1d,0x25,0x00,
+		0x2d,0x20,0x29,0x00,0x31,0x23,0x2c,0x00,0x36,0x26,0x30,0x00,0x38,0x29,0x32,0x00,0x3e,0x2d,0x36,0x00,0x42,0x30,0x39,0x00,
+		0x45,0x33,0x3b,0x00,0x4b,0x38,0x3f,0x00,0x4d,0x3b,0x40,0x00,0x52,0x3e,0x43,0x00,0x59,0x44,0x48,0x00,0x60,0x4b,0x4d,0x00,
+		0x68,0x53,0x52,0x00,0x6f,0x5b,0x58,0x00,0x7a,0x65,0x60,0x00,0x85,0x70,0x69,0x00,0x91,0x7d,0x73,0x00,0x9b,0x86,0x7c,0x00,
+		0xa7,0x91,0x83,0x00,0xb0,0x9a,0x89,0x00,0xb8,0xa3,0x8f,0x00,0xbd,0xa8,0x92,0x00,0xc3,0xad,0x95,0x00,0xc5,0xb0,0x95,0x00,
+		0xc8,0xb2,0x94,0x00,0xca,0xb5,0x96,0x00,0xe0,0xd3,0xbf,0x00,0xf8,0xf5,0xf0,0x00,0xff,0xff,0xff,0x00,0xff,0xfc,0xdf,0x00,
+		0xff,0xf7,0xad,0x00,0xff,0xf3,0x92,0x00,0xff,0xf1,0x90,0x00,0xff,0xef,0x90,0x00,0xff,0xee,0x8c,0x00,0xff,0xec,0x89,0x00,
+		0xff,0xea,0x85,0x00,0xff,0xe8,0x81,0x00,0xff,0xe6,0x7d,0x00,0xff,0xe4,0x79,0x00,0xff,0xe3,0x76,0x00,0xff,0xe0,0x72,0x00,
+		0xff,0xde,0x6e,0x00,0xff,0xdd,0x6a,0x00,0xff,0xdb,0x66,0x00,0xff,0xd9,0x62,0x00,0xff,0xd7,0x5e,0x00,0xff,0xd5,0x59,0x00,
+		0xff,0xd5,0x59,0x00,0xff,0xca,0x36,0x00,0xff,0xb5,0x36,0x00,0xff,0xb7,0x43,0x00,0xff,0xb8,0x43,0x00,0xff,0xb9,0x45,0x00,
+		0xff,0xba,0x47,0x00,0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbf,0x4d,0x00,0xff,0xc0,0x4e,0x00,0xff,0xc1,0x51,0x00,
+		0xff,0xc2,0x53,0x00,0xff,0xc3,0x55,0x00,0xff,0xc5,0x57,0x00,0xff,0xc6,0x59,0x00,0xff,0xc7,0x5b,0x00,0xff,0xc8,0x5e,0x00,
+		0xff,0xc7,0x57,0x00,0xff,0xc9,0x5d,0x00,0xff,0xdd,0x98,0x00,0xff,0xf7,0xe7,0x00,0xff,0xff,0xff,0x00,0xe9,0xeb,0xe8,0x00,
+		0xbe,0xc5,0xbc,0x00,0xa7,0xaf,0xa4,0x00,0xa4,0xac,0xa2,0x00,0xa2,0xa9,0xa0,0x00,0x9c,0xa3,0x9c,0x00,0x98,0x9e,0x98,0x00,
+		0x91,0x97,0x92,0x00,0x88,0x8d,0x89,0x00,0x7e,0x83,0x7f,0x00,0x74,0x79,0x75,0x00,0x69,0x6d,0x6a,0x00,0x60,0x64,0x61,0x00,
+		0x58,0x5b,0x59,0x00,0x53,0x55,0x54,0x00,0x51,0x53,0x52,0x00,0x50,0x52,0x51,0x00,0x52,0x53,0x53,0x00,0x55,0x56,0x56,0x00,
+		0x59,0x5a,0x5a,0x00,0x5c,0x5d,0x5d,0x00,0x5f,0x60,0x60,0x00,0x61,0x62,0x62,0x00,0x63,0x63,0x64,0x00,0x64,0x65,0x65,0x00,
+		0x65,0x65,0x66,0x00,0x64,0x65,0x65,0x00,0x64,0x64,0x65,0x00,0x64,0x65,0x65,0x00,0x64,0x64,0x65,0x00,0x63,0x63,0x64,0x00,
+		0x63,0x63,0x64,0x00,0x61,0x62,0x62,0x00,0x61,0x62,0x62,0x00,0x61,0x62,0x62,0x00,0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,
+		0x60,0x61,0x61,0x00,0x5f,0x60,0x60,0x00,0x60,0x60,0x60,0x00,0x60,0x60,0x60,0x00,0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,
+		0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,0x60,0x61,0x61,0x00,0x60,0x60,0x61,0x00,
+		0x60,0x60,0x61,0x00,0x5f,0x60,0x60,0x00,0x5f,0x60,0x60,0x00,0x5f,0x5f,0x60,0x00,0x5f,0x5f,0x60,0x00,0x5f,0x5f,0x60,0x00,
+		0x5d,0x5e,0x5e,0x00,0x5d,0x5e,0x5f,0x00,0x5c,0x5c,0x5d,0x00,0x5c,0x5c,0x5d,0x00,0x5a,0x5b,0x5b,0x00,0x5a,0x5b,0x5b,0x00,
+		0x5a,0x5b,0x5b,0x00,0x5a,0x5b,0x5b,0x00,0x5b,0x5b,0x5c,0x00,0x5c,0x5c,0x5d,0x00,0x5d,0x5d,0x5d,0x00,0x5e,0x5e,0x5e,0x00,
+		0x5f,0x5f,0x5f,0x00,0x60,0x60,0x60,0x00,0x61,0x60,0x5f,0x00,0x62,0x62,0x61,0x00,0x66,0x65,0x63,0x00,0x6c,0x6c,0x69,0x00,
+		0x74,0x73,0x70,0x00,0x77,0x76,0x73,0x00,0x78,0x76,0x72,0x00,0x76,0x74,0x6f,0x00,0x75,0x73,0x6d,0x00,0x74,0x73,0x6c,0x00,
+		0x74,0x72,0x6b,0x00,0x76,0x73,0x6b,0x00,0x77,0x74,0x6b,0x00,0x79,0x75,0x6b,0x00,0x7b,0x78,0x6c,0x00,0x7f,0x7a,0x6e,0x00,
+		0x82,0x7e,0x70,0x00,0x84,0x7f,0x71,0x00,0x86,0x81,0x72,0x00,0x89,0x84,0x73,0x00,0x8a,0x84,0x74,0x00,0x8b,0x86,0x74,0x00,
+		0x8d,0x86,0x74,0x00,0x8e,0x87,0x74,0x00,0x8f,0x88,0x74,0x00,0x8f,0x88,0x74,0x00,0x8e,0x87,0x73,0x00,0x8e,0x87,0x73,0x00,
+		0x8e,0x86,0x73,0x00,0x8d,0x86,0x72,0x00,0x8c,0x85,0x71,0x00,0x8c,0x84,0x70,0x00,0x8c,0x84,0x70,0x00,0x8b,0x84,0x6f,0x00,
+		0x8b,0x84,0x6f,0x00,0x8c,0x84,0x6f,0x00,0x8c,0x84,0x6f,0x00,0x8c,0x84,0x70,0x00,0x8c,0x84,0x6f,0x00,0x8c,0x84,0x6f,0x00,
+		0x8c,0x84,0x6f,0x00,0x8d,0x85,0x6f,0x00,0x8f,0x87,0x70,0x00,0x8e,0x86,0x6f,0x00,0x8e,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,
+		0x8f,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,0x8f,0x86,0x6f,0x00,
+		0x8e,0x85,0x6e,0x00,0x8d,0x84,0x6d,0x00,0x8d,0x84,0x6c,0x00,0x8c,0x83,0x6d,0x00,0x8b,0x83,0x6c,0x00,0x89,0x81,0x6a,0x00,
+		0x84,0x7e,0x67,0x00,0x81,0x7a,0x63,0x00,0x7b,0x73,0x5d,0x00,0x74,0x6b,0x57,0x00,0x6c,0x65,0x50,0x00,0x66,0x5e,0x48,0x00,
+		0x5c,0x55,0x3f,0x00,0x55,0x4e,0x39,0x00,0x50,0x49,0x33,0x00,0x4b,0x44,0x2e,0x00,0x49,0x41,0x2b,0x00,0x44,0x3e,0x28,0x00,
+		0x45,0x3d,0x27,0x00,0x44,0x3d,0x26,0x00,0x44,0x3d,0x25,0x00,0x43,0x3b,0x25,0x00,0x44,0x3c,0x25,0x00,0x45,0x3e,0x25,0x00,
+		0x45,0x3d,0x25,0x00,0x46,0x3e,0x25,0x00,0x46,0x3e,0x25,0x00,0x46,0x3d,0x25,0x00,0x46,0x3e,0x25,0x00,0x46,0x3d,0x25,0x00,
+		0x47,0x3d,0x25,0x00,0x47,0x3e,0x25,0x00,0x46,0x3d,0x24,0x00,0x46,0x3d,0x24,0x00,0x46,0x3d,0x24,0x00,0x44,0x3d,0x24,0x00,
+		0x42,0x3b,0x23,0x00,0x41,0x39,0x22,0x00,0x3c,0x34,0x1c,0x00,0x32,0x2b,0x13,0x00,0x28,0x20,0x09,0x00,0x22,0x1b,0x04,0x00,
+		0x1e,0x16,0x01,0x00,0x1c,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x10,0x00,0x00,
+		0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x02,0x03,0x00,
+		0x04,0x03,0x04,0x00,0x05,0x03,0x05,0x00,0x07,0x05,0x07,0x00,0x07,0x05,0x07,0x00,0x09,0x06,0x09,0x00,0x0a,0x08,0x0a,0x00,
+		0x0d,0x09,0x0d,0x00,0x0f,0x0b,0x0f,0x00,0x11,0x0c,0x11,0x00,0x14,0x0e,0x14,0x00,0x17,0x0f,0x17,0x00,0x1a,0x12,0x1a,0x00,
+		0x1e,0x14,0x1d,0x00,0x22,0x17,0x21,0x00,0x26,0x1a,0x25,0x00,0x29,0x1d,0x28,0x00,0x2e,0x20,0x2b,0x00,0x32,0x23,0x2e,0x00,
+		0x36,0x26,0x32,0x00,0x3b,0x2a,0x35,0x00,0x40,0x2d,0x39,0x00,0x42,0x30,0x3b,0x00,0x46,0x33,0x3d,0x00,0x4b,0x37,0x41,0x00,
+		0x4f,0x3a,0x42,0x00,0x54,0x3f,0x46,0x00,0x5a,0x44,0x4a,0x00,0x62,0x4b,0x4f,0x00,0x69,0x53,0x55,0x00,0x72,0x5c,0x5c,0x00,
+		0x7e,0x67,0x65,0x00,0x89,0x73,0x6f,0x00,0x94,0x7f,0x78,0x00,0x9f,0x89,0x80,0x00,0xab,0x95,0x89,0x00,0xb4,0x9d,0x8e,0x00,
+		0xbb,0xa5,0x94,0x00,0xc0,0xa9,0x96,0x00,0xc5,0xaf,0x98,0x00,0xc6,0xb0,0x97,0x00,0xd9,0xc8,0xb6,0x00,0xf3,0xed,0xe6,0x00,
+		0xff,0xff,0xff,0x00,0xfe,0xfd,0xec,0x00,0xff,0xfb,0xbe,0x00,0xff,0xf7,0x9b,0x00,0xff,0xf4,0x95,0x00,0xff,0xf3,0x97,0x00,
+		0xff,0xf2,0x94,0x00,0xff,0xef,0x90,0x00,0xff,0xed,0x8c,0x00,0xff,0xec,0x89,0x00,0xff,0xea,0x85,0x00,0xff,0xe8,0x82,0x00,
+		0xff,0xe6,0x7d,0x00,0xff,0xe4,0x7a,0x00,0xff,0xe2,0x75,0x00,0xff,0xe0,0x72,0x00,0xff,0xdf,0x6d,0x00,0xff,0xdc,0x6a,0x00,
+		0xff,0xdb,0x65,0x00,0xff,0xd9,0x62,0x00,0xff,0xd7,0x5d,0x00,0xff,0xd4,0x58,0x00,0xff,0xd4,0x59,0x00,0xff,0xca,0x36,0x00,
+		0xff,0xb4,0x33,0x00,0xff,0xb6,0x40,0x00,0xff,0xb7,0x41,0x00,0xff,0xb8,0x43,0x00,0xff,0xb9,0x45,0x00,0xff,0xbb,0x47,0x00,
+		0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,0xff,0xc0,0x4f,0x00,0xff,0xc1,0x52,0x00,0xff,0xc3,0x54,0x00,
+		0xff,0xc3,0x55,0x00,0xff,0xc5,0x57,0x00,0xff,0xc6,0x59,0x00,0xff,0xc8,0x5b,0x00,0xff,0xc8,0x5d,0x00,0xff,0xc9,0x5c,0x00,
+		0xff,0xc6,0x55,0x00,0xff,0xce,0x69,0x00,0xff,0xe5,0xb2,0x00,0xff,0xfb,0xf3,0x00,0xfd,0xfd,0xfd,0x00,0xdd,0xe0,0xdc,0x00,
+		0xb3,0xbb,0xb2,0x00,0xa3,0xac,0xa3,0x00,0xa1,0xa9,0xa1,0x00,0x9c,0xa3,0x9c,0x00,0x96,0x9d,0x97,0x00,0x90,0x96,0x91,0x00,
+		0x86,0x8c,0x88,0x00,0x7e,0x82,0x7f,0x00,0x75,0x79,0x76,0x00,0x6c,0x70,0x6e,0x00,0x65,0x68,0x67,0x00,0x61,0x64,0x62,0x00,
+		0x5e,0x60,0x5f,0x00,0x5f,0x61,0x60,0x00,0x61,0x63,0x62,0x00,0x65,0x66,0x66,0x00,0x68,0x69,0x69,0x00,0x6c,0x6d,0x6d,0x00,
+		0x6f,0x70,0x70,0x00,0x71,0x72,0x72,0x00,0x72,0x73,0x73,0x00,0x73,0x73,0x74,0x00,0x73,0x74,0x74,0x00,0x73,0x73,0x74,0x00,
+		0x72,0x73,0x73,0x00,0x72,0x73,0x73,0x00,0x72,0x72,0x73,0x00,0x71,0x71,0x72,0x00,0x70,0x70,0x71,0x00,0x70,0x70,0x71,0x00,
+		0x70,0x70,0x71,0x00,0x6f,0x6f,0x70,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6f,0x6f,0x00,
+		0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,
+		0x6e,0x6f,0x6f,0x00,0x6e,0x6f,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,
+		0x6e,0x6e,0x6f,0x00,0x6d,0x6e,0x6f,0x00,0x6d,0x6d,0x6e,0x00,0x6d,0x6d,0x6e,0x00,0x6c,0x6c,0x6d,0x00,0x6b,0x6b,0x6c,0x00,
+		0x6a,0x6b,0x6b,0x00,0x69,0x6a,0x6a,0x00,0x68,0x69,0x69,0x00,0x67,0x68,0x68,0x00,0x67,0x68,0x68,0x00,0x69,0x69,0x69,0x00,
+		0x6a,0x6a,0x6a,0x00,0x6a,0x6a,0x6a,0x00,0x6b,0x6b,0x6c,0x00,0x6c,0x6c,0x6c,0x00,0x6d,0x6d,0x6d,0x00,0x6e,0x6e,0x6d,0x00,
+		0x70,0x70,0x6f,0x00,0x75,0x75,0x74,0x00,0x7d,0x7d,0x7b,0x00,0x83,0x82,0x80,0x00,0x84,0x84,0x81,0x00,0x84,0x83,0x7f,0x00,
+		0x84,0x82,0x7e,0x00,0x83,0x81,0x7c,0x00,0x83,0x80,0x7a,0x00,0x82,0x7f,0x79,0x00,0x82,0x7f,0x78,0x00,0x84,0x80,0x77,0x00,
+		0x84,0x81,0x78,0x00,0x86,0x83,0x78,0x00,0x8a,0x85,0x79,0x00,0x8c,0x88,0x7a,0x00,0x8f,0x8a,0x7b,0x00,0x92,0x8d,0x7e,0x00,
+		0x95,0x90,0x7f,0x00,0x96,0x90,0x7f,0x00,0x98,0x91,0x7f,0x00,0x9a,0x93,0x7f,0x00,0x9b,0x94,0x80,0x00,0x9b,0x95,0x80,0x00,
+		0x9b,0x95,0x7f,0x00,0x9c,0x95,0x7f,0x00,0x9b,0x94,0x7f,0x00,0x9c,0x95,0x7f,0x00,0x9b,0x94,0x7e,0x00,0x9b,0x93,0x7d,0x00,
+		0x9b,0x93,0x7c,0x00,0x9b,0x93,0x7c,0x00,0x9b,0x92,0x7b,0x00,0x9b,0x92,0x7b,0x00,0x9b,0x92,0x7b,0x00,0x9b,0x92,0x7b,0x00,
+		0x9b,0x92,0x7b,0x00,0x9b,0x93,0x7b,0x00,0x9b,0x93,0x7b,0x00,0x9b,0x94,0x7b,0x00,0x9b,0x93,0x7b,0x00,0x9b,0x93,0x7b,0x00,
+		0x9b,0x93,0x7a,0x00,0x9b,0x93,0x7a,0x00,0x9b,0x93,0x7a,0x00,0x9c,0x93,0x7a,0x00,0x9c,0x93,0x79,0x00,0x9c,0x94,0x7a,0x00,
+		0x9c,0x93,0x7a,0x00,0x9c,0x93,0x79,0x00,0x9c,0x94,0x7a,0x00,0x9c,0x94,0x79,0x00,0x9c,0x93,0x7a,0x00,0x9b,0x93,0x7a,0x00,
+		0x9b,0x92,0x79,0x00,0x9a,0x91,0x78,0x00,0x98,0x8f,0x78,0x00,0x96,0x8d,0x75,0x00,0x93,0x8a,0x72,0x00,0x8e,0x85,0x6e,0x00,
+		0x88,0x7f,0x67,0x00,0x80,0x77,0x60,0x00,0x77,0x6f,0x58,0x00,0x6f,0x67,0x50,0x00,0x65,0x5c,0x46,0x00,0x5d,0x56,0x3e,0x00,
+		0x55,0x4d,0x37,0x00,0x4f,0x47,0x31,0x00,0x4d,0x44,0x2d,0x00,0x4a,0x41,0x29,0x00,0x48,0x3e,0x28,0x00,0x47,0x3f,0x26,0x00,
+		0x46,0x3e,0x25,0x00,0x46,0x3e,0x25,0x00,0x47,0x3e,0x25,0x00,0x48,0x3e,0x25,0x00,0x49,0x3f,0x25,0x00,0x49,0x3f,0x25,0x00,
+		0x49,0x40,0x25,0x00,0x48,0x3f,0x25,0x00,0x4a,0x40,0x25,0x00,0x49,0x40,0x25,0x00,0x49,0x40,0x25,0x00,0x49,0x40,0x24,0x00,
+		0x48,0x3f,0x24,0x00,0x47,0x3f,0x24,0x00,0x48,0x3e,0x23,0x00,0x42,0x3a,0x1f,0x00,0x3d,0x34,0x19,0x00,0x33,0x29,0x0e,0x00,
+		0x2b,0x22,0x07,0x00,0x27,0x1d,0x02,0x00,0x23,0x1a,0x00,0x00,0x21,0x18,0x00,0x00,0x20,0x17,0x00,0x00,0x1e,0x16,0x00,0x00,
+		0x1c,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x10,0x00,0x00,0x13,0x0e,0x00,0x00,
+		0x11,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x08,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,0x06,0x04,0x06,0x00,
+		0x06,0x04,0x07,0x00,0x08,0x06,0x09,0x00,0x09,0x07,0x09,0x00,0x0b,0x08,0x0b,0x00,0x0d,0x09,0x0d,0x00,0x10,0x0a,0x10,0x00,
+		0x13,0x0c,0x13,0x00,0x15,0x0e,0x15,0x00,0x18,0x0f,0x18,0x00,0x1b,0x12,0x1b,0x00,0x1e,0x14,0x1e,0x00,0x23,0x18,0x22,0x00,
+		0x26,0x1a,0x25,0x00,0x2c,0x1d,0x2a,0x00,0x2e,0x20,0x2c,0x00,0x33,0x23,0x2f,0x00,0x37,0x26,0x33,0x00,0x3b,0x2a,0x36,0x00,
+		0x41,0x2d,0x3b,0x00,0x45,0x30,0x3d,0x00,0x47,0x33,0x3f,0x00,0x4d,0x36,0x43,0x00,0x50,0x3a,0x45,0x00,0x56,0x3f,0x49,0x00,
+		0x5c,0x44,0x4d,0x00,0x63,0x4b,0x52,0x00,0x6b,0x52,0x58,0x00,0x73,0x5c,0x5f,0x00,0x7f,0x67,0x68,0x00,0x8c,0x73,0x72,0x00,
+		0x97,0x7f,0x7c,0x00,0xa2,0x8a,0x84,0x00,0xad,0x94,0x8b,0x00,0xb5,0x9d,0x91,0x00,0xbd,0xa4,0x96,0x00,0xc2,0xa9,0x99,0x00,
+		0xc5,0xad,0x9a,0x00,0xec,0xe2,0xdb,0x00,0xfd,0xfc,0xfb,0x00,0xff,0xff,0xf5,0x00,0xff,0xfe,0xce,0x00,0xff,0xfa,0xa7,0x00,
+		0xfe,0xf8,0x9a,0x00,0xff,0xf7,0x9d,0x00,0xff,0xf5,0x9a,0x00,0xff,0xf3,0x96,0x00,0xff,0xf1,0x93,0x00,0xff,0xef,0x90,0x00,
+		0xff,0xed,0x8b,0x00,0xff,0xeb,0x88,0x00,0xff,0xe9,0x84,0x00,0xff,0xe7,0x81,0x00,0xff,0xe6,0x7d,0x00,0xff,0xe4,0x79,0x00,
+		0xff,0xe2,0x75,0x00,0xff,0xe0,0x71,0x00,0xff,0xde,0x6d,0x00,0xff,0xdc,0x69,0x00,0xff,0xdb,0x65,0x00,0xff,0xd9,0x61,0x00,
+		0xff,0xd7,0x5d,0x00,0xff,0xd4,0x58,0x00,0xff,0xd4,0x59,0x00,0xff,0xc9,0x35,0x00,0xff,0xb3,0x30,0x00,0xff,0xb4,0x3e,0x00,
+		0xff,0xb6,0x3f,0x00,0xff,0xb7,0x41,0x00,0xff,0xb8,0x43,0x00,0xff,0xb9,0x45,0x00,0xff,0xba,0x47,0x00,0xff,0xbc,0x4a,0x00,
+		0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,0xff,0xbf,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc3,0x55,0x00,
+		0xff,0xc5,0x57,0x00,0xff,0xc6,0x59,0x00,0xff,0xc7,0x5b,0x00,0xff,0xc8,0x5c,0x00,0xff,0xc9,0x60,0x00,0xff,0xc9,0x5d,0x00,
+		0xff,0xc8,0x59,0x00,0xff,0xd4,0x7c,0x00,0xff,0xed,0xc9,0x00,0xff,0xfe,0xfd,0x00,0xf5,0xf6,0xf5,0x00,0xce,0xd3,0xce,0x00,
+		0xa5,0xaf,0xa7,0x00,0x9f,0xa7,0xa0,0x00,0x9a,0xa1,0x9b,0x00,0x95,0x9c,0x96,0x00,0x8e,0x94,0x90,0x00,0x86,0x8c,0x88,0x00,
+		0x7e,0x83,0x80,0x00,0x78,0x7c,0x79,0x00,0x72,0x75,0x74,0x00,0x6e,0x71,0x6f,0x00,0x6c,0x6f,0x6e,0x00,0x6d,0x6f,0x6f,0x00,
+		0x6f,0x71,0x70,0x00,0x72,0x73,0x73,0x00,0x76,0x77,0x77,0x00,0x78,0x79,0x79,0x00,0x7b,0x7c,0x7c,0x00,0x7d,0x7e,0x7e,0x00,
+		0x7d,0x7e,0x7e,0x00,0x7e,0x7f,0x7f,0x00,0x7e,0x7f,0x7f,0x00,0x7e,0x7f,0x7f,0x00,0x7d,0x7e,0x7e,0x00,0x7d,0x7d,0x7e,0x00,
+		0x7d,0x7d,0x7e,0x00,0x7c,0x7c,0x7d,0x00,0x7c,0x7c,0x7d,0x00,0x7b,0x7b,0x7c,0x00,0x7b,0x7b,0x7c,0x00,0x7a,0x7a,0x7b,0x00,
+		0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,
+		0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,
+		0x7a,0x7a,0x7b,0x00,0x79,0x7a,0x7b,0x00,0x7a,0x7a,0x7b,0x00,0x79,0x7a,0x7a,0x00,0x78,0x79,0x79,0x00,0x78,0x78,0x79,0x00,
+		0x78,0x79,0x79,0x00,0x77,0x78,0x78,0x00,0x77,0x78,0x79,0x00,0x77,0x77,0x78,0x00,0x75,0x76,0x76,0x00,0x75,0x75,0x76,0x00,
+		0x74,0x75,0x76,0x00,0x74,0x75,0x76,0x00,0x74,0x75,0x76,0x00,0x75,0x75,0x75,0x00,0x75,0x75,0x75,0x00,0x75,0x75,0x76,0x00,
+		0x77,0x77,0x77,0x00,0x77,0x77,0x77,0x00,0x79,0x7a,0x79,0x00,0x7c,0x7c,0x7b,0x00,0x83,0x83,0x82,0x00,0x8a,0x8a,0x88,0x00,
+		0x8d,0x8d,0x8c,0x00,0x8f,0x8f,0x8c,0x00,0x8f,0x8e,0x8a,0x00,0x8f,0x8d,0x8a,0x00,0x8f,0x8d,0x89,0x00,0x8d,0x8b,0x86,0x00,
+		0x8d,0x8b,0x84,0x00,0x8e,0x8b,0x84,0x00,0x8e,0x8a,0x83,0x00,0x8f,0x8b,0x82,0x00,0x90,0x8d,0x82,0x00,0x93,0x8f,0x83,0x00,
+		0x95,0x90,0x84,0x00,0x99,0x94,0x85,0x00,0x9b,0x95,0x85,0x00,0x9e,0x98,0x87,0x00,0x9f,0x9a,0x88,0x00,0xa1,0x9b,0x88,0x00,
+		0xa4,0x9c,0x89,0x00,0xa5,0x9d,0x89,0x00,0xa6,0x9e,0x89,0x00,0xa6,0x9f,0x89,0x00,0xa7,0x9f,0x89,0x00,0xa7,0x9f,0x88,0x00,
+		0xa7,0x9f,0x88,0x00,0xa7,0x9f,0x87,0x00,0xa7,0x9f,0x86,0x00,0xa7,0x9f,0x86,0x00,0xa6,0x9e,0x85,0x00,0xa6,0x9d,0x84,0x00,
+		0xa6,0x9d,0x84,0x00,0xa6,0x9d,0x84,0x00,0xa6,0x9d,0x84,0x00,0xa5,0x9c,0x83,0x00,0xa6,0x9d,0x84,0x00,0xa6,0x9d,0x84,0x00,
+		0xa7,0x9e,0x84,0x00,0xa7,0x9e,0x84,0x00,0xa7,0x9e,0x84,0x00,0xa8,0x9f,0x84,0x00,0xa9,0x9f,0x84,0x00,0xa8,0x9e,0x83,0x00,
+		0xa8,0x9e,0x83,0x00,0xa9,0xa0,0x84,0x00,0xa8,0x9f,0x83,0x00,0xa8,0x9f,0x83,0x00,0xa8,0x9f,0x83,0x00,0xa8,0x9f,0x83,0x00,
+		0xa8,0x9f,0x83,0x00,0xa8,0x9e,0x83,0x00,0xa7,0x9d,0x83,0x00,0xa7,0x9d,0x83,0x00,0xa5,0x9d,0x82,0x00,0xa5,0x9d,0x82,0x00,
+		0xa4,0x9a,0x81,0x00,0xa1,0x98,0x7e,0x00,0x9d,0x94,0x7b,0x00,0x99,0x8f,0x77,0x00,0x93,0x8a,0x71,0x00,0x8a,0x82,0x69,0x00,
+		0x81,0x78,0x60,0x00,0x77,0x6d,0x56,0x00,0x6d,0x64,0x4d,0x00,0x64,0x5b,0x43,0x00,0x5a,0x51,0x3a,0x00,0x55,0x4c,0x33,0x00,
+		0x4f,0x46,0x2e,0x00,0x4c,0x44,0x2a,0x00,0x49,0x40,0x28,0x00,0x49,0x3f,0x26,0x00,0x49,0x3f,0x25,0x00,0x49,0x3f,0x25,0x00,
+		0x49,0x3f,0x25,0x00,0x4a,0x40,0x25,0x00,0x4b,0x41,0x25,0x00,0x4b,0x41,0x25,0x00,0x4c,0x42,0x25,0x00,0x4c,0x42,0x25,0x00,
+		0x4c,0x42,0x25,0x00,0x4c,0x41,0x24,0x00,0x4c,0x42,0x25,0x00,0x4c,0x42,0x24,0x00,0x4a,0x40,0x23,0x00,0x48,0x3d,0x20,0x00,
+		0x40,0x35,0x17,0x00,0x36,0x2a,0x0c,0x00,0x2f,0x24,0x06,0x00,0x2b,0x21,0x02,0x00,0x29,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,
+		0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x21,0x18,0x00,0x00,0x20,0x17,0x00,0x00,0x1d,0x15,0x00,0x00,0x1c,0x14,0x00,0x00,
+		0x1a,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x11,0x00,0x00,0x14,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x04,0x07,0x00,0x09,0x06,0x09,0x00,
+		0x0a,0x07,0x0a,0x00,0x0b,0x08,0x0b,0x00,0x0d,0x09,0x0d,0x00,0x10,0x0a,0x10,0x00,0x12,0x0c,0x13,0x00,0x16,0x0e,0x16,0x00,
+		0x18,0x0f,0x18,0x00,0x1c,0x12,0x1c,0x00,0x20,0x14,0x1f,0x00,0x24,0x17,0x23,0x00,0x28,0x1a,0x27,0x00,0x2c,0x1d,0x2b,0x00,
+		0x2f,0x20,0x2e,0x00,0x33,0x23,0x31,0x00,0x38,0x26,0x35,0x00,0x3e,0x29,0x39,0x00,0x41,0x2c,0x3d,0x00,0x46,0x2f,0x3f,0x00,
+		0x49,0x32,0x42,0x00,0x4e,0x36,0x45,0x00,0x52,0x39,0x48,0x00,0x57,0x3e,0x4b,0x00,0x5d,0x43,0x4f,0x00,0x63,0x4a,0x54,0x00,
+		0x6b,0x52,0x5a,0x00,0x76,0x5b,0x62,0x00,0x81,0x66,0x6b,0x00,0x8d,0x74,0x76,0x00,0x99,0x7f,0x7f,0x00,0xa4,0x89,0x87,0x00,
+		0xae,0x93,0x8f,0x00,0xb7,0x9d,0x95,0x00,0xbe,0xa5,0x9a,0x00,0xc3,0xa9,0x9c,0x00,0xc5,0xac,0x9c,0x00,0xfe,0xfe,0xfe,0x00,
+		0xfe,0xfe,0xf5,0x00,0xfe,0xfd,0xb9,0x00,0xff,0xfd,0x9c,0x00,0xff,0xfa,0xa2,0x00,0xff,0xf9,0xa1,0x00,0xff,0xf6,0x9e,0x00,
+		0xfe,0xf4,0x99,0x00,0xff,0xf3,0x97,0x00,0xff,0xf1,0x93,0x00,0xff,0xef,0x8f,0x00,0xff,0xed,0x8b,0x00,0xff,0xec,0x88,0x00,
+		0xff,0xe9,0x84,0x00,0xff,0xe7,0x81,0x00,0xff,0xe5,0x7c,0x00,0xff,0xe3,0x79,0x00,0xff,0xe2,0x75,0x00,0xff,0xdf,0x71,0x00,
+		0xff,0xde,0x6d,0x00,0xff,0xdc,0x69,0x00,0xff,0xda,0x65,0x00,0xff,0xd8,0x61,0x00,0xff,0xd7,0x5d,0x00,0xff,0xd4,0x58,0x00,
+		0xff,0xd4,0x59,0x00,0xff,0xc9,0x34,0x00,0xff,0xb2,0x30,0x00,0xff,0xb3,0x3c,0x00,0xff,0xb5,0x3e,0x00,0xff,0xb6,0x3f,0x00,
+		0xff,0xb7,0x41,0x00,0xff,0xb8,0x43,0x00,0xff,0xb9,0x45,0x00,0xff,0xbb,0x47,0x00,0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,
+		0xff,0xbf,0x4d,0x00,0xff,0xc1,0x4f,0x00,0xff,0xc1,0x51,0x00,0xff,0xc2,0x53,0x00,0xff,0xc4,0x55,0x00,0xff,0xc5,0x57,0x00,
+		0xff,0xc6,0x59,0x00,0xff,0xc7,0x5b,0x00,0xff,0xc8,0x5d,0x00,0xff,0xc9,0x5f,0x00,0xff,0xcb,0x61,0x00,0xff,0xca,0x5b,0x00,
+		0xff,0xc9,0x58,0x00,0xff,0xda,0x8c,0x00,0xff,0xfa,0xf0,0x00,0xff,0xff,0xff,0x00,0xe7,0xea,0xe8,0x00,0xa9,0xb2,0xab,0x00,
+		0x9d,0xa6,0xa0,0x00,0x98,0xa0,0x9b,0x00,0x93,0x9a,0x95,0x00,0x8e,0x93,0x90,0x00,0x87,0x8d,0x89,0x00,0x82,0x86,0x84,0x00,
+		0x7d,0x81,0x7f,0x00,0x7a,0x7d,0x7c,0x00,0x7a,0x7c,0x7b,0x00,0x79,0x7c,0x7b,0x00,0x7c,0x7e,0x7e,0x00,0x7e,0x80,0x7f,0x00,
+		0x81,0x82,0x82,0x00,0x83,0x84,0x84,0x00,0x84,0x85,0x85,0x00,0x86,0x87,0x87,0x00,0x87,0x88,0x88,0x00,0x86,0x87,0x87,0x00,
+		0x87,0x87,0x88,0x00,0x86,0x86,0x87,0x00,0x86,0x86,0x87,0x00,0x85,0x86,0x87,0x00,0x85,0x86,0x86,0x00,0x84,0x84,0x85,0x00,
+		0x84,0x84,0x85,0x00,0x83,0x84,0x85,0x00,0x84,0x84,0x85,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,
+		0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,
+		0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x82,0x83,0x84,0x00,
+		0x82,0x83,0x84,0x00,0x83,0x83,0x84,0x00,0x82,0x83,0x84,0x00,0x82,0x82,0x83,0x00,0x82,0x83,0x83,0x00,0x81,0x81,0x82,0x00,
+		0x80,0x80,0x81,0x00,0x80,0x80,0x81,0x00,0x7f,0x80,0x80,0x00,0x7e,0x7e,0x7f,0x00,0x7e,0x7e,0x7f,0x00,0x7e,0x7e,0x7f,0x00,
+		0x7e,0x7e,0x7f,0x00,0x7e,0x7e,0x7f,0x00,0x7e,0x7e,0x7f,0x00,0x7e,0x7f,0x7f,0x00,0x80,0x81,0x81,0x00,0x81,0x82,0x81,0x00,
+		0x88,0x88,0x88,0x00,0x8f,0x8f,0x8e,0x00,0x96,0x96,0x95,0x00,0x96,0x96,0x95,0x00,0x97,0x97,0x95,0x00,0x97,0x96,0x94,0x00,
+		0x97,0x96,0x93,0x00,0x97,0x95,0x92,0x00,0x97,0x95,0x90,0x00,0x97,0x95,0x8f,0x00,0x97,0x95,0x8e,0x00,0x97,0x95,0x8c,0x00,
+		0x98,0x95,0x8c,0x00,0x9a,0x96,0x8b,0x00,0x9b,0x96,0x8b,0x00,0x9d,0x99,0x8b,0x00,0xa0,0x9b,0x8c,0x00,0xa2,0x9c,0x8d,0x00,
+		0xa4,0x9e,0x8e,0x00,0xa6,0xa1,0x8e,0x00,0xaa,0xa3,0x8f,0x00,0xab,0xa3,0x8f,0x00,0xac,0xa5,0x90,0x00,0xac,0xa6,0x8f,0x00,
+		0xae,0xa6,0x90,0x00,0xaf,0xa6,0x90,0x00,0xb0,0xa7,0x8f,0x00,0xb1,0xa7,0x8f,0x00,0xb0,0xa7,0x8e,0x00,0xb1,0xa7,0x8d,0x00,
+		0xb1,0xa7,0x8d,0x00,0xb1,0xa7,0x8d,0x00,0xb1,0xa7,0x8d,0x00,0xb1,0xa7,0x8d,0x00,0xb0,0xa6,0x8c,0x00,0xb1,0xa6,0x8b,0x00,
+		0xb1,0xa6,0x8b,0x00,0xb1,0xa7,0x8b,0x00,0xb1,0xa6,0x8b,0x00,0xb1,0xa7,0x8b,0x00,0xb2,0xa8,0x8b,0x00,0xb2,0xa8,0x8b,0x00,
+		0xb1,0xa7,0x8a,0x00,0xb1,0xa7,0x8a,0x00,0xb2,0xa8,0x8b,0x00,0xb1,0xa7,0x8a,0x00,0xb2,0xa8,0x8b,0x00,0xb1,0xa7,0x8a,0x00,
+		0xb1,0xa7,0x89,0x00,0xb1,0xa7,0x89,0x00,0xb1,0xa7,0x8a,0x00,0xb1,0xa7,0x8a,0x00,0xb1,0xa7,0x8a,0x00,0xb1,0xa7,0x8a,0x00,
+		0xb0,0xa6,0x89,0x00,0xb1,0xa7,0x8a,0x00,0xb0,0xa6,0x8a,0x00,0xaf,0xa5,0x89,0x00,0xae,0xa5,0x89,0x00,0xab,0xa1,0x87,0x00,
+		0xa9,0xa0,0x85,0x00,0xa3,0x99,0x7f,0x00,0x9c,0x93,0x78,0x00,0x93,0x8a,0x71,0x00,0x88,0x7f,0x66,0x00,0x7e,0x76,0x5c,0x00,
+		0x73,0x6a,0x51,0x00,0x68,0x60,0x46,0x00,0x5f,0x55,0x3d,0x00,0x57,0x4f,0x34,0x00,0x52,0x4a,0x2f,0x00,0x4f,0x45,0x2b,0x00,
+		0x4c,0x44,0x28,0x00,0x4c,0x42,0x27,0x00,0x4b,0x41,0x26,0x00,0x4a,0x41,0x25,0x00,0x4c,0x42,0x25,0x00,0x4d,0x42,0x25,0x00,
+		0x4d,0x42,0x25,0x00,0x4e,0x43,0x25,0x00,0x4e,0x42,0x25,0x00,0x4e,0x43,0x25,0x00,0x4e,0x43,0x25,0x00,0x4e,0x43,0x25,0x00,
+		0x4d,0x41,0x23,0x00,0x49,0x3d,0x1e,0x00,0x42,0x37,0x15,0x00,0x38,0x2c,0x0a,0x00,0x33,0x26,0x04,0x00,0x2f,0x23,0x01,0x00,
+		0x2d,0x21,0x00,0x00,0x2c,0x21,0x00,0x00,0x2b,0x1f,0x00,0x00,0x29,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,
+		0x23,0x1a,0x00,0x00,0x22,0x19,0x00,0x00,0x20,0x17,0x00,0x00,0x1d,0x16,0x00,0x00,0x1c,0x14,0x00,0x00,0x19,0x12,0x00,0x00,
+		0x17,0x11,0x00,0x00,0x15,0x10,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,
+		0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x04,0x07,0x00,0x08,0x05,0x08,0x00,0x09,0x07,0x09,0x00,0x0c,0x07,0x0c,0x00,
+		0x0d,0x08,0x0e,0x00,0x10,0x0b,0x11,0x00,0x13,0x0c,0x13,0x00,0x16,0x0e,0x16,0x00,0x19,0x0f,0x19,0x00,0x1c,0x12,0x1d,0x00,
+		0x20,0x14,0x20,0x00,0x24,0x17,0x24,0x00,0x29,0x1a,0x28,0x00,0x2d,0x1c,0x2c,0x00,0x30,0x20,0x2f,0x00,0x35,0x22,0x33,0x00,
+		0x38,0x25,0x36,0x00,0x3e,0x28,0x3b,0x00,0x41,0x2b,0x3e,0x00,0x45,0x2e,0x40,0x00,0x4b,0x32,0x44,0x00,0x4e,0x35,0x46,0x00,
+		0x53,0x39,0x4b,0x00,0x59,0x3e,0x4f,0x00,0x5d,0x42,0x50,0x00,0x66,0x4a,0x58,0x00,0x6d,0x51,0x5e,0x00,0x77,0x5a,0x65,0x00,
+		0x82,0x67,0x70,0x00,0x8f,0x72,0x79,0x00,0x9a,0x7e,0x81,0x00,0xa5,0x89,0x8a,0x00,0xaf,0x93,0x91,0x00,0xb7,0x9b,0x97,0x00,
+		0xbd,0xa1,0x9b,0x00,0xc3,0xa8,0x9e,0x00,0xc5,0xaa,0x9e,0x00,0xfe,0xfd,0xfe,0x00,0xfe,0xfe,0xfd,0x00,0xfe,0xfe,0xef,0x00,
+		0xff,0xfd,0xc5,0x00,0xfe,0xf9,0xa1,0x00,0xff,0xf7,0x9b,0x00,0xfe,0xf5,0x9c,0x00,0xfe,0xf3,0x99,0x00,0xff,0xf2,0x96,0x00,
+		0xff,0xf1,0x92,0x00,0xff,0xef,0x8f,0x00,0xff,0xed,0x8b,0x00,0xff,0xeb,0x87,0x00,0xff,0xe9,0x83,0x00,0xff,0xe7,0x80,0x00,
+		0xff,0xe6,0x7c,0x00,0xff,0xe3,0x78,0x00,0xff,0xe2,0x74,0x00,0xff,0xe0,0x71,0x00,0xff,0xde,0x6c,0x00,0xff,0xdc,0x69,0x00,
+		0xff,0xda,0x65,0x00,0xff,0xd8,0x60,0x00,0xff,0xd6,0x5c,0x00,0xff,0xd4,0x57,0x00,0xff,0xd4,0x58,0x00,0xff,0xc8,0x33,0x00,
+		0xff,0xb1,0x2d,0x00,0xff,0xb1,0x3a,0x00,0xff,0xb3,0x3b,0x00,0xff,0xb5,0x3e,0x00,0xff,0xb6,0x3f,0x00,0xff,0xb7,0x41,0x00,
+		0xff,0xb8,0x43,0x00,0xff,0xb9,0x45,0x00,0xff,0xba,0x47,0x00,0xff,0xbc,0x49,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,
+		0xff,0xbf,0x4e,0x00,0xff,0xc1,0x50,0x00,0xff,0xc2,0x53,0x00,0xff,0xc3,0x55,0x00,0xff,0xc4,0x57,0x00,0xff,0xc6,0x5a,0x00,
+		0xff,0xc7,0x5b,0x00,0xff,0xc8,0x5d,0x00,0xff,0xc8,0x5a,0x00,0xff,0xc6,0x55,0x00,0xff,0xd1,0x74,0x00,0xff,0xe8,0xb9,0x00,
+		0xff,0xfc,0xf7,0x00,0xff,0xff,0xff,0x00,0xf9,0xf9,0xf9,0x00,0xb2,0xbb,0xb5,0x00,0x9e,0xa8,0xa2,0x00,0x9b,0xa4,0x9e,0x00,
+		0x98,0x9f,0x9a,0x00,0x93,0x9a,0x96,0x00,0x8e,0x94,0x90,0x00,0x8a,0x8f,0x8c,0x00,0x87,0x8b,0x89,0x00,0x84,0x88,0x86,0x00,
+		0x83,0x87,0x85,0x00,0x84,0x87,0x86,0x00,0x85,0x88,0x87,0x00,0x87,0x89,0x88,0x00,0x89,0x8a,0x8a,0x00,0x8a,0x8c,0x8c,0x00,
+		0x8b,0x8d,0x8d,0x00,0x8c,0x8d,0x8d,0x00,0x8d,0x8e,0x8e,0x00,0x8e,0x8e,0x8f,0x00,0x8d,0x8d,0x8e,0x00,0x8c,0x8d,0x8d,0x00,
+		0x8b,0x8c,0x8d,0x00,0x8b,0x8c,0x8c,0x00,0x8b,0x8b,0x8c,0x00,0x8b,0x8b,0x8c,0x00,0x89,0x8a,0x8a,0x00,0x89,0x8a,0x8b,0x00,
+		0x89,0x8a,0x8b,0x00,0x89,0x8a,0x8b,0x00,0x89,0x89,0x8a,0x00,0x89,0x8a,0x8b,0x00,0x89,0x8a,0x8b,0x00,0x89,0x8a,0x8b,0x00,
+		0x89,0x8a,0x8b,0x00,0x89,0x8a,0x8a,0x00,0x89,0x8a,0x8a,0x00,0x89,0x8a,0x8a,0x00,0x89,0x8a,0x8a,0x00,0x89,0x8a,0x8b,0x00,
+		0x89,0x8a,0x8b,0x00,0x89,0x89,0x8a,0x00,0x89,0x89,0x8a,0x00,0x89,0x89,0x8a,0x00,0x89,0x89,0x8a,0x00,0x88,0x89,0x8a,0x00,
+		0x88,0x88,0x89,0x00,0x87,0x88,0x89,0x00,0x87,0x87,0x88,0x00,0x87,0x87,0x89,0x00,0x86,0x86,0x87,0x00,0x86,0x87,0x87,0x00,
+		0x86,0x86,0x87,0x00,0x85,0x85,0x86,0x00,0x85,0x85,0x86,0x00,0x84,0x84,0x85,0x00,0x83,0x84,0x85,0x00,0x84,0x84,0x85,0x00,
+		0x85,0x85,0x86,0x00,0x85,0x86,0x86,0x00,0x89,0x8a,0x8a,0x00,0x91,0x91,0x91,0x00,0x97,0x97,0x97,0x00,0x9b,0x9b,0x99,0x00,
+		0x9b,0x9b,0x99,0x00,0x9b,0x9b,0x9a,0x00,0x9c,0x9b,0x9a,0x00,0x9c,0x9b,0x99,0x00,0x9d,0x9b,0x99,0x00,0x9d,0x9c,0x97,0x00,
+		0x9d,0x9b,0x96,0x00,0x9d,0x9b,0x95,0x00,0x9e,0x9b,0x94,0x00,0x9e,0x9b,0x93,0x00,0xa0,0x9c,0x92,0x00,0xa1,0x9d,0x92,0x00,
+		0xa3,0x9e,0x91,0x00,0xa4,0x9f,0x91,0x00,0xa7,0xa1,0x92,0x00,0xa9,0xa3,0x92,0x00,0xac,0xa5,0x93,0x00,0xae,0xa7,0x93,0x00,
+		0xb0,0xa8,0x94,0x00,0xb2,0xaa,0x94,0x00,0xb2,0xab,0x93,0x00,0xb4,0xac,0x94,0x00,0xb5,0xac,0x93,0x00,0xb6,0xac,0x93,0x00,
+		0xb7,0xad,0x93,0x00,0xb7,0xad,0x93,0x00,0xb8,0xae,0x92,0x00,0xb8,0xad,0x92,0x00,0xb8,0xad,0x91,0x00,0xb8,0xae,0x91,0x00,
+		0xb8,0xae,0x91,0x00,0xb8,0xae,0x91,0x00,0xb8,0xad,0x90,0x00,0xb8,0xad,0x90,0x00,0xb7,0xac,0x90,0x00,0xb8,0xad,0x90,0x00,
+		0xb8,0xae,0x90,0x00,0xb8,0xae,0x90,0x00,0xb8,0xae,0x90,0x00,0xb8,0xad,0x90,0x00,0xb9,0xaf,0x90,0x00,0xb8,0xae,0x8f,0x00,
+		0xb9,0xaf,0x90,0x00,0xb8,0xae,0x8f,0x00,0xb8,0xae,0x8f,0x00,0xb8,0xae,0x8f,0x00,0xb8,0xae,0x8f,0x00,0xb8,0xad,0x8f,0x00,
+		0xb8,0xae,0x8f,0x00,0xb8,0xae,0x8f,0x00,0xb7,0xac,0x8e,0x00,0xb8,0xae,0x8f,0x00,0xb8,0xad,0x90,0x00,0xb5,0xaa,0x8e,0x00,
+		0xb7,0xac,0x8f,0x00,0xb7,0xac,0x8f,0x00,0xb4,0xaa,0x8e,0x00,0xb0,0xa7,0x8c,0x00,0xaf,0xa5,0x89,0x00,0xa9,0x9f,0x85,0x00,
+		0xa2,0x99,0x7e,0x00,0x9a,0x91,0x76,0x00,0x90,0x87,0x6c,0x00,0x85,0x7b,0x60,0x00,0x79,0x6f,0x56,0x00,0x6e,0x65,0x4a,0x00,
+		0x64,0x5b,0x40,0x00,0x5b,0x51,0x37,0x00,0x55,0x4b,0x30,0x00,0x50,0x47,0x2b,0x00,0x4f,0x45,0x28,0x00,0x4e,0x43,0x27,0x00,
+		0x4e,0x43,0x26,0x00,0x4e,0x43,0x25,0x00,0x4f,0x43,0x25,0x00,0x4e,0x43,0x25,0x00,0x4e,0x44,0x25,0x00,0x4f,0x44,0x25,0x00,
+		0x50,0x44,0x25,0x00,0x50,0x45,0x25,0x00,0x4f,0x44,0x22,0x00,0x4b,0x3e,0x1d,0x00,0x43,0x37,0x13,0x00,0x3b,0x2e,0x0a,0x00,
+		0x37,0x29,0x04,0x00,0x34,0x26,0x01,0x00,0x32,0x25,0x00,0x00,0x32,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2f,0x23,0x00,0x00,
+		0x2d,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x2a,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,
+		0x21,0x19,0x00,0x00,0x1e,0x17,0x00,0x00,0x1d,0x15,0x00,0x00,0x1b,0x14,0x00,0x00,0x18,0x12,0x00,0x00,0x16,0x10,0x00,0x00,
+		0x14,0x0e,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x09,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x05,0x04,0x06,0x00,
+		0x07,0x04,0x07,0x00,0x08,0x05,0x08,0x00,0x09,0x07,0x0a,0x00,0x0c,0x07,0x0c,0x00,0x0e,0x09,0x0f,0x00,0x10,0x0a,0x12,0x00,
+		0x13,0x0c,0x14,0x00,0x16,0x0e,0x17,0x00,0x1a,0x10,0x1b,0x00,0x1d,0x12,0x1e,0x00,0x21,0x14,0x21,0x00,0x25,0x17,0x25,0x00,
+		0x2a,0x1a,0x2a,0x00,0x2d,0x1c,0x2d,0x00,0x31,0x1f,0x30,0x00,0x35,0x22,0x34,0x00,0x3a,0x25,0x38,0x00,0x3e,0x28,0x3d,0x00,
+		0x41,0x2a,0x3e,0x00,0x47,0x2e,0x43,0x00,0x4a,0x30,0x45,0x00,0x4f,0x34,0x49,0x00,0x52,0x37,0x4b,0x00,0x5a,0x3c,0x50,0x00,
+		0x5e,0x40,0x53,0x00,0x64,0x47,0x59,0x00,0x6c,0x4f,0x5e,0x00,0x78,0x5a,0x68,0x00,0x82,0x64,0x71,0x00,0x8e,0x70,0x7a,0x00,
+		0x9a,0x7c,0x83,0x00,0xa4,0x86,0x8b,0x00,0xaf,0x91,0x93,0x00,0xb7,0x99,0x99,0x00,0xbd,0xa0,0x9d,0x00,0xc1,0xa4,0x9f,0x00,
+		0xc6,0xaa,0xa1,0x00,0xfd,0xf2,0xff,0x00,0xeb,0x9b,0xfb,0x00,0xf6,0xdb,0xfe,0x00,0xfe,0xfe,0xfe,0x00,0xff,0xff,0xe4,0x00,
+		0xfe,0xf9,0xb2,0x00,0xff,0xf6,0x97,0x00,0xfe,0xf2,0x95,0x00,0xfe,0xf1,0x95,0x00,0xfe,0xf0,0x91,0x00,0xff,0xee,0x8e,0x00,
+		0xff,0xed,0x8a,0x00,0xff,0xeb,0x87,0x00,0xff,0xe9,0x83,0x00,0xff,0xe7,0x80,0x00,0xff,0xe5,0x7c,0x00,0xff,0xe3,0x78,0x00,
+		0xff,0xe2,0x74,0x00,0xff,0xdf,0x70,0x00,0xff,0xde,0x6c,0x00,0xff,0xdc,0x68,0x00,0xff,0xda,0x64,0x00,0xff,0xd8,0x60,0x00,
+		0xff,0xd6,0x5c,0x00,0xff,0xd5,0x58,0x00,0xff,0xd4,0x58,0x00,0xff,0xc8,0x33,0x00,0xff,0xb0,0x2c,0x00,0xff,0xb1,0x38,0x00,
+		0xff,0xb2,0x39,0x00,0xff,0xb3,0x3a,0x00,0xff,0xb5,0x3d,0x00,0xff,0xb6,0x3f,0x00,0xff,0xb7,0x41,0x00,0xff,0xb8,0x43,0x00,
+		0xff,0xb9,0x45,0x00,0xff,0xba,0x47,0x00,0xff,0xbc,0x49,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4e,0x00,0xff,0xc0,0x4f,0x00,
+		0xff,0xc1,0x51,0x00,0xff,0xc3,0x53,0x00,0xff,0xc3,0x55,0x00,0xff,0xc5,0x57,0x00,0xff,0xc5,0x57,0x00,0xff,0xc3,0x50,0x00,
+		0xff,0xca,0x62,0x00,0xff,0xe1,0xa7,0x00,0xff,0xfa,0xf2,0x00,0xff,0xff,0xff,0x00,0xc6,0xf7,0xe7,0x00,0xbe,0xf6,0xe1,0x00,
+		0xf5,0xf8,0xf6,0x00,0xb0,0xba,0xb4,0x00,0xa0,0xaa,0xa4,0x00,0x9d,0xa6,0xa0,0x00,0x9a,0xa2,0x9e,0x00,0x97,0x9e,0x9a,0x00,
+		0x94,0x9a,0x96,0x00,0x90,0x96,0x93,0x00,0x8e,0x93,0x91,0x00,0x8d,0x91,0x8f,0x00,0x8c,0x8f,0x8e,0x00,0x8c,0x8f,0x8e,0x00,
+		0x8c,0x8f,0x8e,0x00,0x8f,0x91,0x90,0x00,0x8f,0x91,0x90,0x00,0x91,0x92,0x92,0x00,0x9c,0x9d,0x9d,0x00,0xb4,0xb5,0xb6,0x00,
+		0xcd,0xce,0xce,0x00,0xd0,0xd1,0xd1,0x00,0xcf,0xd0,0xd0,0x00,0xcf,0xd0,0xd0,0x00,0xcf,0xd0,0xd0,0x00,0xcb,0xcb,0xcc,0x00,
+		0xc5,0xc5,0xc6,0x00,0xc0,0xc0,0xc0,0x00,0xba,0xba,0xbb,0x00,0xa9,0xaa,0xaa,0x00,0x95,0x96,0x96,0x00,0x8c,0x8d,0x8e,0x00,
+		0x8c,0x8d,0x8e,0x00,0x8c,0x8d,0x8e,0x00,0x8c,0x8d,0x8d,0x00,0xa3,0xa3,0xa4,0x00,0xb7,0xb8,0xb9,0x00,0xb7,0xb8,0xb9,0x00,
+		0xb7,0xb7,0xb8,0x00,0xb7,0xb7,0xb8,0x00,0xb7,0xb7,0xb8,0x00,0xb7,0xb7,0xb8,0x00,0xb7,0xb7,0xb7,0x00,0xb7,0xb7,0xb7,0x00,
+		0xb7,0xb7,0xb7,0x00,0xb7,0xb7,0xb7,0x00,0xb7,0xb7,0xb7,0x00,0xb6,0xb7,0xb7,0x00,0xb7,0xb7,0xb7,0x00,0xb6,0xb6,0xb7,0x00,
+		0xb6,0xb6,0xb7,0x00,0xb7,0xb7,0xb7,0x00,0xb3,0xb4,0xb5,0x00,0x9e,0x9f,0x9f,0x00,0x8a,0x8b,0x8b,0x00,0x89,0x8a,0x8b,0x00,
+		0x89,0x89,0x8a,0x00,0x88,0x89,0x8a,0x00,0x88,0x89,0x8a,0x00,0x88,0x89,0x8a,0x00,0x8b,0x8b,0x8c,0x00,0x90,0x90,0x90,0x00,
+		0xa6,0xa6,0xa6,0x00,0xc1,0xc1,0xc1,0x00,0xc2,0xc2,0xc2,0x00,0xc2,0xc2,0xc1,0x00,0xc2,0xc2,0xc1,0x00,0xc2,0xc2,0xc1,0x00,
+		0xc3,0xc3,0xc1,0x00,0xc3,0xc3,0xc2,0x00,0xc5,0xc3,0xc2,0x00,0xbe,0xbd,0xba,0x00,0xa4,0xa2,0x9e,0x00,0xa2,0xa1,0x9a,0x00,
+		0xa3,0xa1,0x99,0x00,0xa4,0xa1,0x97,0x00,0xa5,0xa1,0x97,0x00,0xa6,0xa2,0x96,0x00,0xa8,0xa3,0x95,0x00,0xab,0xa5,0x96,0x00,
+		0xac,0xa6,0x96,0x00,0xae,0xa7,0x96,0x00,0xb4,0xad,0x9b,0x00,0xc2,0xbc,0xac,0x00,0xc7,0xc1,0xb1,0x00,0xce,0xc9,0xb8,0x00,
+		0xd4,0xd0,0xc2,0x00,0xdd,0xd7,0xc9,0x00,0xe5,0xdf,0xce,0x00,0xe9,0xe1,0xce,0x00,0xe7,0xe1,0xcf,0x00,0xe4,0xdd,0xcb,0x00,
+		0xdf,0xd9,0xc7,0x00,0xda,0xd4,0xc3,0x00,0xd8,0xd2,0xc0,0x00,0xd0,0xc9,0xb3,0x00,0xc6,0xbc,0xa1,0x00,0xbd,0xb2,0x93,0x00,
+		0xbd,0xb2,0x93,0x00,0xbd,0xb2,0x93,0x00,0xbd,0xb2,0x93,0x00,0xbd,0xb2,0x93,0x00,0xbd,0xb2,0x93,0x00,0xce,0xc7,0xaf,0x00,
+		0xd5,0xce,0xbb,0x00,0xd5,0xce,0xba,0x00,0xd5,0xce,0xba,0x00,0xd5,0xce,0xba,0x00,0xd5,0xce,0xba,0x00,0xd5,0xce,0xba,0x00,
+		0xd6,0xcf,0xbb,0x00,0xd5,0xce,0xba,0x00,0xd5,0xce,0xba,0x00,0xd4,0xcd,0xba,0x00,0xd4,0xcd,0xba,0x00,0xd4,0xcd,0xba,0x00,
+		0xd5,0xce,0xba,0x00,0xd5,0xcd,0xba,0x00,0xd3,0xcd,0xba,0x00,0xd3,0xcd,0xbb,0x00,0xd4,0xce,0xbb,0x00,0xd3,0xcd,0xbc,0x00,
+		0xd2,0xcc,0xba,0x00,0xd2,0xcb,0xb9,0x00,0xc1,0xb8,0xa0,0x00,0xb0,0xa5,0x89,0x00,0xa9,0x9f,0x83,0x00,0xa1,0x97,0x7c,0x00,
+		0x95,0x8c,0x70,0x00,0x89,0x7f,0x65,0x00,0x7d,0x73,0x59,0x00,0x72,0x68,0x4d,0x00,0x67,0x5e,0x42,0x00,0x5f,0x55,0x39,0x00,
+		0x58,0x4e,0x32,0x00,0x53,0x49,0x2c,0x00,0x50,0x46,0x28,0x00,0x4f,0x45,0x27,0x00,0x4f,0x44,0x26,0x00,0x4f,0x44,0x25,0x00,
+		0x50,0x46,0x25,0x00,0x51,0x45,0x25,0x00,0x51,0x46,0x25,0x00,0x51,0x46,0x24,0x00,0x50,0x44,0x21,0x00,0x4a,0x3e,0x1a,0x00,
+		0x43,0x36,0x10,0x00,0x3d,0x2f,0x08,0x00,0x39,0x2a,0x02,0x00,0x37,0x29,0x00,0x00,0x37,0x28,0x00,0x00,0x36,0x27,0x00,0x00,
+		0x34,0x27,0x00,0x00,0x33,0x26,0x00,0x00,0x33,0x25,0x00,0x00,0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2e,0x22,0x00,0x00,
+		0x2c,0x21,0x00,0x00,0x2a,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x20,0x18,0x00,0x00,
+		0x1e,0x16,0x00,0x00,0x1c,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x13,0x0e,0x00,0x00,
+		0x11,0x0d,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x06,0x04,0x06,0x00,0x08,0x05,0x08,0x00,
+		0x09,0x06,0x0a,0x00,0x0c,0x08,0x0c,0x00,0x0e,0x09,0x0f,0x00,0x11,0x0a,0x12,0x00,0x14,0x0c,0x15,0x00,0x17,0x0d,0x18,0x00,
+		0x1a,0x0f,0x1b,0x00,0x1e,0x12,0x1f,0x00,0x21,0x14,0x22,0x00,0x24,0x17,0x26,0x00,0x29,0x19,0x29,0x00,0x2e,0x1b,0x2e,0x00,
+		0x31,0x1e,0x31,0x00,0x36,0x21,0x35,0x00,0x3a,0x24,0x39,0x00,0x3f,0x27,0x3d,0x00,0x42,0x29,0x40,0x00,0x48,0x2c,0x45,0x00,
+		0x4a,0x2f,0x46,0x00,0x4f,0x32,0x4b,0x00,0x53,0x36,0x4d,0x00,0x59,0x3a,0x52,0x00,0x5e,0x3e,0x55,0x00,0x65,0x46,0x5b,0x00,
+		0x6d,0x4d,0x61,0x00,0x77,0x58,0x69,0x00,0x82,0x61,0x72,0x00,0x8f,0x6f,0x7d,0x00,0x9a,0x7a,0x86,0x00,0xa5,0x84,0x8d,0x00,
+		0xae,0x8e,0x95,0x00,0xb6,0x97,0x9b,0x00,0xbc,0x9e,0x9f,0x00,0xc1,0xa3,0xa1,0x00,0xc4,0xa6,0xa1,0x00,0xfd,0xf3,0xff,0x00,
+		0xd7,0x48,0xf4,0x00,0xd5,0x3d,0xf4,0x00,0xeb,0xa1,0xfb,0x00,0xfc,0xf5,0xfe,0x00,0xfe,0xfe,0xfa,0x00,0xfe,0xfc,0xd2,0x00,
+		0xff,0xf5,0xa1,0x00,0xff,0xf2,0x8f,0x00,0xff,0xf0,0x8f,0x00,0xff,0xee,0x8f,0x00,0xff,0xed,0x8a,0x00,0xff,0xeb,0x87,0x00,
+		0xff,0xe9,0x83,0x00,0xff,0xe7,0x80,0x00,0xff,0xe5,0x7c,0x00,0xff,0xe3,0x78,0x00,0xff,0xe1,0x74,0x00,0xff,0xdf,0x70,0x00,
+		0xff,0xdd,0x6c,0x00,0xff,0xdc,0x68,0x00,0xff,0xda,0x64,0x00,0xff,0xd8,0x5f,0x00,0xff,0xd6,0x5b,0x00,0xff,0xd4,0x56,0x00,
+		0xff,0xd3,0x57,0x00,0xff,0xc8,0x32,0x00,0xff,0xae,0x29,0x00,0xff,0xb0,0x36,0x00,0xff,0xb1,0x37,0x00,0xff,0xb2,0x38,0x00,
+		0xff,0xb3,0x3b,0x00,0xff,0xb5,0x3d,0x00,0xff,0xb5,0x3f,0x00,0xff,0xb7,0x41,0x00,0xff,0xb8,0x44,0x00,0xff,0xb9,0x45,0x00,
+		0xff,0xba,0x47,0x00,0xff,0xbc,0x4a,0x00,0xff,0xbd,0x4c,0x00,0xff,0xbe,0x4d,0x00,0xff,0xbf,0x4f,0x00,0xff,0xc1,0x52,0x00,
+		0xff,0xc2,0x52,0x00,0xff,0xc0,0x4b,0x00,0xff,0xc2,0x52,0x00,0xff,0xd7,0x8d,0x00,0xff,0xf5,0xe3,0x00,0xff,0xff,0xff,0x00,
+		0xdf,0xfb,0xf2,0x00,0x95,0xef,0xce,0x00,0x5c,0xe6,0xb6,0x00,0xa1,0xf0,0xd4,0x00,0xf6,0xf8,0xf7,0x00,0xb0,0xbb,0xb5,0x00,
+		0xa0,0xab,0xa4,0x00,0x9e,0xa8,0xa2,0x00,0x9c,0xa5,0xa0,0x00,0x9a,0xa2,0x9e,0x00,0x98,0x9f,0x9c,0x00,0x95,0x9b,0x98,0x00,
+		0x93,0x98,0x96,0x00,0x92,0x96,0x95,0x00,0x91,0x95,0x93,0x00,0x92,0x95,0x94,0x00,0x92,0x95,0x94,0x00,0x92,0x95,0x94,0x00,
+		0x9a,0x9c,0x9b,0x00,0xc2,0xc3,0xc3,0x00,0xe2,0xe2,0xe2,0x00,0xe7,0xe7,0xe8,0x00,0xcd,0xcd,0xce,0x00,0xab,0xac,0xae,0x00,
+		0xab,0xac,0xae,0x00,0xab,0xac,0xae,0x00,0xb0,0xb1,0xb2,0x00,0xbc,0xbd,0xbe,0x00,0xc8,0xc8,0xc9,0x00,0xd1,0xd1,0xd2,0x00,
+		0xdf,0xdf,0xe0,0x00,0xe6,0xe6,0xe7,0x00,0xdf,0xdf,0xdf,0x00,0xcc,0xcd,0xcd,0x00,0xa7,0xa8,0xa9,0x00,0x8f,0x90,0x91,0x00,
+		0x8e,0x8f,0x90,0x00,0xc4,0xc5,0xc5,0x00,0xe5,0xe5,0xe6,0x00,0xd5,0xd5,0xd6,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,
+		0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,
+		0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd6,0xd6,0xd7,0x00,0xd5,0xd5,0xd6,0x00,
+		0xe4,0xe4,0xe5,0x00,0xe3,0xe3,0xe4,0x00,0xd7,0xd7,0xd8,0x00,0xaf,0xaf,0xb0,0x00,0x8d,0x8e,0x8f,0x00,0x8a,0x8b,0x8c,0x00,
+		0x8b,0x8c,0x8d,0x00,0x8e,0x8f,0x8f,0x00,0x93,0x94,0x94,0x00,0x9a,0x9a,0x9b,0x00,0xc0,0xc0,0xc0,0x00,0xf6,0xf2,0xe5,0x00,
+		0xf9,0xee,0xd0,0x00,0xf8,0xee,0xd0,0x00,0xf8,0xee,0xd1,0x00,0xf8,0xee,0xd1,0x00,0xf8,0xee,0xd1,0x00,0xf8,0xee,0xd0,0x00,
+		0xfa,0xf1,0xda,0x00,0xee,0xea,0xdf,0x00,0xad,0xac,0xa6,0x00,0xa6,0xa3,0x9c,0x00,0xa6,0xa3,0x9b,0x00,0xa6,0xa3,0x9a,0x00,
+		0xa8,0xa5,0x9a,0x00,0xaa,0xa6,0x99,0x00,0xac,0xa6,0x99,0x00,0xac,0xa7,0x98,0x00,0xb4,0xaf,0x9f,0x00,0xce,0xca,0xbe,0x00,
+		0xea,0xe6,0xde,0x00,0xf6,0xf1,0xe3,0x00,0xf8,0xf2,0xdf,0x00,0xfa,0xf2,0xdc,0x00,0xfb,0xf1,0xd4,0x00,0xfb,0xed,0xc5,0x00,
+		0xfb,0xe8,0xb1,0x00,0xfc,0xe4,0x9f,0x00,0xfc,0xe5,0xa6,0x00,0xfb,0xe8,0xb3,0x00,0xfb,0xeb,0xbf,0x00,0xfb,0xef,0xca,0x00,
+		0xfb,0xf1,0xd5,0x00,0xf9,0xf4,0xe4,0x00,0xf4,0xef,0xe1,0x00,0xeb,0xe6,0xd9,0x00,0xdc,0xd6,0xc3,0x00,0xce,0xc4,0xaa,0x00,
+		0xc3,0xb8,0x98,0x00,0xc1,0xb5,0x94,0x00,0xc1,0xb5,0x93,0x00,0xec,0xe6,0xd4,0x00,0xfc,0xf4,0xe0,0x00,0xfa,0xee,0xcd,0x00,
+		0xfb,0xf0,0xcf,0x00,0xfb,0xf0,0xd0,0x00,0xfa,0xef,0xcf,0x00,0xfa,0xef,0xcf,0x00,0xfa,0xef,0xcf,0x00,0xfa,0xef,0xcf,0x00,
+		0xf9,0xee,0xce,0x00,0xf9,0xee,0xce,0x00,0xfa,0xef,0xcf,0x00,0xf9,0xee,0xce,0x00,0xf9,0xee,0xce,0x00,0xfa,0xef,0xcf,0x00,
+		0xf9,0xee,0xce,0x00,0xf9,0xee,0xce,0x00,0xf8,0xed,0xce,0x00,0xf9,0xee,0xce,0x00,0xf8,0xed,0xcc,0x00,0xf7,0xf1,0xe0,0x00,
+		0xd5,0xcf,0xbf,0x00,0xb3,0xa9,0x8c,0x00,0xac,0xa3,0x86,0x00,0xa3,0x99,0x7d,0x00,0x99,0x8f,0x73,0x00,0x8e,0x83,0x68,0x00,
+		0x80,0x77,0x5a,0x00,0x75,0x6b,0x4f,0x00,0x6a,0x60,0x44,0x00,0x60,0x56,0x39,0x00,0x5a,0x4f,0x32,0x00,0x55,0x4a,0x2d,0x00,
+		0x53,0x49,0x29,0x00,0x51,0x46,0x27,0x00,0x51,0x46,0x26,0x00,0x51,0x45,0x25,0x00,0x51,0x46,0x25,0x00,0x52,0x46,0x24,0x00,
+		0x50,0x44,0x21,0x00,0x4b,0x3f,0x19,0x00,0x44,0x36,0x0f,0x00,0x3e,0x2f,0x07,0x00,0x3c,0x2d,0x03,0x00,0x3a,0x2a,0x00,0x00,
+		0x39,0x2b,0x00,0x00,0x39,0x2a,0x00,0x00,0x38,0x2a,0x00,0x00,0x39,0x2a,0x00,0x00,0x37,0x29,0x00,0x00,0x36,0x28,0x00,0x00,
+		0x34,0x27,0x00,0x00,0x33,0x26,0x00,0x00,0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2e,0x21,0x00,0x00,0x2c,0x21,0x00,0x00,
+		0x29,0x1e,0x00,0x00,0x27,0x1d,0x00,0x00,0x24,0x1b,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x1a,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x14,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,
+		0x0d,0x0a,0x00,0x00,0x0b,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,
+		0x04,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x06,0x04,0x07,0x00,0x08,0x05,0x08,0x00,0x0a,0x06,0x0a,0x00,0x0c,0x07,0x0d,0x00,
+		0x0e,0x09,0x0f,0x00,0x11,0x0a,0x12,0x00,0x14,0x0c,0x15,0x00,0x17,0x0d,0x18,0x00,0x1b,0x0f,0x1c,0x00,0x1d,0x11,0x1e,0x00,
+		0x21,0x14,0x22,0x00,0x25,0x16,0x26,0x00,0x29,0x19,0x2a,0x00,0x2d,0x1b,0x2e,0x00,0x32,0x1e,0x33,0x00,0x36,0x20,0x37,0x00,
+		0x3b,0x23,0x3b,0x00,0x3f,0x26,0x3f,0x00,0x42,0x28,0x41,0x00,0x47,0x2b,0x45,0x00,0x4c,0x2d,0x49,0x00,0x4f,0x31,0x4c,0x00,
+		0x54,0x35,0x4f,0x00,0x58,0x38,0x53,0x00,0x5e,0x3d,0x57,0x00,0x65,0x44,0x5d,0x00,0x6d,0x4b,0x63,0x00,0x77,0x54,0x6b,0x00,
+		0x83,0x60,0x74,0x00,0x8e,0x6b,0x7e,0x00,0x99,0x76,0x87,0x00,0xa4,0x82,0x90,0x00,0xae,0x8c,0x98,0x00,0xb6,0x94,0x9d,0x00,
+		0xbb,0x9b,0xa0,0x00,0xc1,0xa1,0xa4,0x00,0xc2,0xa3,0xa3,0x00,0xfc,0xf3,0xfe,0x00,0xda,0x54,0xf6,0x00,0xcf,0x28,0xf3,0x00,
+		0xd0,0x2a,0xf3,0x00,0xda,0x58,0xf5,0x00,0xf1,0xbf,0xfe,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xf3,0x00,0xff,0xf8,0xc0,0x00,
+		0xfe,0xef,0x90,0x00,0xff,0xed,0x87,0x00,0xff,0xed,0x89,0x00,0xff,0xea,0x87,0x00,0xff,0xe9,0x83,0x00,0xff,0xe7,0x80,0x00,
+		0xff,0xe5,0x7b,0x00,0xff,0xe3,0x77,0x00,0xff,0xe1,0x74,0x00,0xff,0xdf,0x70,0x00,0xff,0xde,0x6c,0x00,0xff,0xdc,0x67,0x00,
+		0xff,0xda,0x63,0x00,0xff,0xd8,0x5f,0x00,0xff,0xd6,0x5b,0x00,0xff,0xd4,0x57,0x00,0xff,0xd3,0x57,0x00,0xff,0xc8,0x32,0x00,
+		0xff,0xad,0x26,0x00,0xff,0xae,0x33,0x00,0xff,0xb1,0x34,0x00,0xff,0xb1,0x36,0x00,0xff,0xb2,0x39,0x00,0xff,0xb4,0x3b,0x00,
+		0xff,0xb5,0x3d,0x00,0xff,0xb6,0x3f,0x00,0xff,0xb7,0x42,0x00,0xff,0xb9,0x43,0x00,0xff,0xba,0x46,0x00,0xff,0xbb,0x47,0x00,
+		0xff,0xbc,0x4a,0x00,0xff,0xbe,0x4c,0x00,0xff,0xbf,0x4e,0x00,0xff,0xbd,0x48,0x00,0xff,0xbd,0x47,0x00,0xff,0xcd,0x75,0x00,
+		0xff,0xed,0xcc,0x00,0xff,0xff,0xff,0x00,0xeb,0xfe,0xfb,0x00,0xa5,0xf2,0xd6,0x00,0x68,0xe8,0xb8,0x00,0x5f,0xe6,0xb5,0x00,
+		0x5e,0xe7,0xb6,0x00,0xa6,0xf1,0xd6,0x00,0xf6,0xf8,0xf7,0x00,0xb1,0xbc,0xb5,0x00,0xa0,0xac,0xa5,0x00,0x9f,0xaa,0xa4,0x00,
+		0x9e,0xa7,0xa2,0x00,0x9d,0xa5,0xa1,0x00,0x9a,0xa2,0x9e,0x00,0x99,0x9f,0x9c,0x00,0x98,0x9d,0x9b,0x00,0x97,0x9b,0x9a,0x00,
+		0x96,0x9a,0x98,0x00,0x96,0x99,0x98,0x00,0x95,0x98,0x97,0x00,0xaa,0xac,0xac,0x00,0xdf,0xe0,0xe0,0x00,0xe7,0xe7,0xe8,0x00,
+		0xb0,0xb1,0xb3,0x00,0x71,0x72,0x75,0x00,0x4a,0x4d,0x50,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4a,0x4e,0x00,0x56,0x59,0x5c,0x00,0x7a,0x7c,0x7f,0x00,
+		0xa8,0xa9,0xab,0x00,0xd5,0xd5,0xd6,0x00,0xe9,0xe9,0xe9,0x00,0xc4,0xc4,0xc5,0x00,0x8f,0x90,0x90,0x00,0xc4,0xc5,0xc5,0x00,
+		0xc5,0xc5,0xc6,0x00,0x4b,0x4e,0x51,0x00,0x4e,0x51,0x54,0x00,0x4e,0x50,0x54,0x00,0x4e,0x51,0x54,0x00,0x4e,0x51,0x54,0x00,
+		0x4e,0x50,0x54,0x00,0x4e,0x50,0x54,0x00,0x4e,0x51,0x54,0x00,0x4e,0x50,0x54,0x00,0x4e,0x50,0x54,0x00,0x4e,0x50,0x54,0x00,
+		0x4e,0x51,0x54,0x00,0x4e,0x50,0x54,0x00,0x4e,0x50,0x54,0x00,0x4c,0x4f,0x52,0x00,0x62,0x63,0x67,0x00,0x8f,0x90,0x93,0x00,
+		0xc7,0xc8,0xc9,0x00,0xe7,0xe8,0xe8,0x00,0xd8,0xd8,0xd9,0x00,0xa8,0xa9,0xa9,0x00,0x92,0x93,0x94,0x00,0x98,0x99,0x9a,0x00,
+		0x9d,0x9d,0x9e,0x00,0x9d,0x9d,0x9e,0x00,0xc1,0xc1,0xc0,0x00,0xf7,0xec,0xcd,0x00,0xff,0xce,0x40,0x00,0xff,0xc9,0x2c,0x00,
+		0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2b,0x00,0xff,0xda,0x73,0x00,0xf0,0xea,0xda,0x00,
+		0xae,0xac,0xa6,0x00,0xa6,0xa4,0x9c,0x00,0xa7,0xa5,0x9b,0x00,0xa9,0xa6,0x9b,0x00,0xab,0xa6,0x9b,0x00,0xac,0xa8,0x9b,0x00,
+		0xae,0xa9,0x9a,0x00,0xc7,0xc3,0xb8,0x00,0xec,0xea,0xe2,0x00,0xf8,0xf3,0xe5,0x00,0xfb,0xe9,0xb8,0x00,0xff,0xd9,0x6c,0x00,
+		0xff,0xd0,0x4a,0x00,0xff,0xcd,0x3d,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc7,0x27,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc8,0x28,0x00,0xff,0xc9,0x30,0x00,0xff,0xd2,0x52,0x00,
+		0xff,0xde,0x80,0x00,0xfc,0xea,0xb6,0x00,0xfa,0xf1,0xd6,0x00,0xf8,0xf4,0xe6,0x00,0xe1,0xda,0xc6,0x00,0xc3,0xb6,0x93,0x00,
+		0xc3,0xb6,0x92,0x00,0xef,0xe8,0xd4,0x00,0xfe,0xe2,0x90,0x00,0xff,0xc9,0x2b,0x00,0xff,0xc9,0x2f,0x00,0xfe,0xc8,0x2f,0x00,
+		0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc9,0x2f,0x00,0xfe,0xc8,0x2f,0x00,0xfe,0xc8,0x2f,0x00,
+		0xfe,0xc8,0x2f,0x00,0xfd,0xc7,0x2f,0x00,0xfd,0xc7,0x2f,0x00,0xfe,0xc8,0x2f,0x00,0xfd,0xc7,0x2f,0x00,0xfd,0xc7,0x2f,0x00,
+		0xfc,0xc7,0x2e,0x00,0xfd,0xc7,0x2f,0x00,0xfc,0xc6,0x2d,0x00,0xf8,0xe9,0xc1,0x00,0xd7,0xd2,0xc1,0x00,0xb5,0xaa,0x8e,0x00,
+		0xaf,0xa4,0x88,0x00,0xa6,0x9c,0x7f,0x00,0x9c,0x92,0x75,0x00,0x91,0x87,0x6a,0x00,0x83,0x79,0x5d,0x00,0x77,0x6d,0x4f,0x00,
+		0x6c,0x61,0x44,0x00,0x62,0x59,0x3a,0x00,0x5b,0x50,0x33,0x00,0x57,0x4c,0x2e,0x00,0x54,0x48,0x29,0x00,0x52,0x47,0x27,0x00,
+		0x52,0x47,0x26,0x00,0x52,0x45,0x24,0x00,0x50,0x43,0x20,0x00,0x4b,0x3d,0x17,0x00,0x43,0x36,0x0d,0x00,0x3f,0x31,0x06,0x00,
+		0x3c,0x2d,0x01,0x00,0x3c,0x2d,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3d,0x2c,0x00,0x00,0x3d,0x2c,0x00,0x00,0x3c,0x2c,0x00,0x00,
+		0x3b,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,0x39,0x2a,0x00,0x00,0x38,0x29,0x00,0x00,0x37,0x29,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x33,0x26,0x00,0x00,0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2d,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x28,0x1e,0x00,0x00,
+		0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,
+		0x17,0x11,0x00,0x00,0x14,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x09,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x05,0x04,0x06,0x00,
+		0x06,0x04,0x07,0x00,0x08,0x05,0x08,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x07,0x0d,0x00,0x0f,0x08,0x10,0x00,0x12,0x0a,0x13,0x00,
+		0x14,0x0b,0x15,0x00,0x17,0x0d,0x18,0x00,0x1a,0x0f,0x1c,0x00,0x1e,0x11,0x20,0x00,0x21,0x13,0x23,0x00,0x27,0x16,0x28,0x00,
+		0x2a,0x18,0x2b,0x00,0x2d,0x1a,0x2f,0x00,0x32,0x1d,0x34,0x00,0x36,0x20,0x38,0x00,0x3b,0x22,0x3b,0x00,0x3f,0x25,0x40,0x00,
+		0x43,0x27,0x43,0x00,0x47,0x2a,0x47,0x00,0x4b,0x2c,0x49,0x00,0x4f,0x2f,0x4d,0x00,0x54,0x32,0x50,0x00,0x59,0x37,0x56,0x00,
+		0x5d,0x3a,0x57,0x00,0x65,0x41,0x5e,0x00,0x6d,0x49,0x65,0x00,0x77,0x53,0x6d,0x00,0x81,0x5d,0x76,0x00,0x8d,0x68,0x7f,0x00,
+		0x98,0x74,0x88,0x00,0xa2,0x7f,0x91,0x00,0xad,0x8a,0x99,0x00,0xb5,0x92,0x9e,0x00,0xbb,0x98,0xa3,0x00,0xbf,0x9e,0xa5,0x00,
+		0xc2,0xa1,0xa5,0x00,0xfc,0xf3,0xfd,0x00,0xd8,0x54,0xf4,0x00,0xd0,0x2f,0xf4,0x00,0xd1,0x38,0xf3,0x00,0xce,0x2d,0xf1,0x00,
+		0xd0,0x30,0xf3,0x00,0xde,0x75,0xf7,0x00,0xf6,0xda,0xfe,0x00,0xff,0xff,0xff,0x00,0xfe,0xfe,0xe4,0x00,0xff,0xf3,0xaa,0x00,
+		0xff,0xeb,0x83,0x00,0xff,0xe9,0x80,0x00,0xff,0xe9,0x83,0x00,0xff,0xe7,0x7f,0x00,0xff,0xe5,0x7b,0x00,0xff,0xe3,0x77,0x00,
+		0xff,0xe1,0x73,0x00,0xff,0xdf,0x6f,0x00,0xff,0xdd,0x6b,0x00,0xff,0xdb,0x67,0x00,0xff,0xd9,0x63,0x00,0xff,0xd7,0x5f,0x00,
+		0xff,0xd5,0x5a,0x00,0xff,0xd3,0x56,0x00,0xff,0xd3,0x57,0x00,0xff,0xc8,0x31,0x00,0xff,0xac,0x24,0x00,0xff,0xac,0x30,0x00,
+		0xff,0xaf,0x32,0x00,0xff,0xb0,0x35,0x00,0xff,0xb1,0x37,0x00,0xff,0xb2,0x39,0x00,0xff,0xb3,0x3b,0x00,0xff,0xb5,0x3e,0x00,
+		0xff,0xb5,0x3f,0x00,0xff,0xb7,0x42,0x00,0xff,0xb8,0x44,0x00,0xff,0xb9,0x45,0x00,0xff,0xbb,0x48,0x00,0xff,0xba,0x45,0x00,
+		0xff,0xb9,0x40,0x00,0xff,0xc3,0x5d,0x00,0xff,0xe4,0xb4,0x00,0xff,0xfd,0xf9,0x00,0xf8,0xff,0xff,0x00,0xb8,0xf4,0xdd,0x00,
+		0x6e,0xe9,0xba,0x00,0x58,0xe6,0xb1,0x00,0x61,0xe8,0xb6,0x00,0x67,0xe8,0xb8,0x00,0x5f,0xe7,0xb6,0x00,0xa4,0xf1,0xd6,0x00,
+		0xf6,0xf8,0xf7,0x00,0xb0,0xbc,0xb5,0x00,0xa0,0xad,0xa6,0x00,0x9f,0xaa,0xa4,0x00,0x9f,0xa9,0xa3,0x00,0x9e,0xa7,0xa2,0x00,
+		0x9c,0xa4,0xa0,0x00,0x9b,0xa1,0x9e,0x00,0x9a,0xa0,0x9d,0x00,0x99,0x9e,0x9c,0x00,0x98,0x9c,0x9b,0x00,0x97,0x9b,0x9a,0x00,
+		0xa2,0xa5,0xa4,0x00,0xe4,0xe4,0xe4,0x00,0xd1,0xd2,0xd3,0x00,0x70,0x72,0x75,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x57,0x59,0x5c,0x00,
+		0xb1,0xb2,0xb4,0x00,0xd7,0xd7,0xd8,0x00,0x90,0x90,0x91,0x00,0xc3,0xc3,0xc3,0x00,0xc6,0xc6,0xc7,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x4e,0x50,0x54,0x00,0x7f,0x80,0x83,0x00,
+		0xcb,0xcc,0xcd,0x00,0xe9,0xe9,0xea,0x00,0xb6,0xb7,0xb7,0x00,0x9c,0x9d,0x9e,0x00,0x9c,0x9d,0x9d,0x00,0x9d,0x9d,0x9d,0x00,
+		0xc1,0xc0,0xc0,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x39,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x6f,0x00,0xef,0xea,0xda,0x00,0xae,0xac,0xa6,0x00,0xa6,0xa4,0x9d,0x00,
+		0xa8,0xa6,0x9c,0x00,0xaa,0xa6,0x9b,0x00,0xac,0xa8,0x9b,0x00,0xb1,0xac,0x9f,0x00,0xd6,0xd3,0xcb,0x00,0xf5,0xf2,0xea,0x00,
+		0xf9,0xe8,0xb8,0x00,0xff,0xd3,0x56,0x00,0xff,0xc8,0x29,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x27,0x00,
+		0xff,0xce,0x40,0x00,0xfc,0xe9,0xb2,0x00,0xe9,0xe1,0xcb,0x00,0xc4,0xb7,0x92,0x00,0xc4,0xb7,0x92,0x00,0xef,0xe7,0xd3,0x00,
+		0xfd,0xe1,0x91,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,
+		0xfd,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfc,0xc4,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfd,0xc4,0x26,0x00,
+		0xfd,0xc6,0x28,0x00,0xf9,0xeb,0xc4,0x00,0xd7,0xd2,0xc1,0x00,0xb5,0xaa,0x8e,0x00,0xb0,0xa6,0x88,0x00,0xa7,0x9d,0x80,0x00,
+		0x9e,0x93,0x77,0x00,0x92,0x87,0x6b,0x00,0x85,0x7b,0x5e,0x00,0x78,0x6e,0x4f,0x00,0x6d,0x62,0x44,0x00,0x63,0x58,0x3a,0x00,
+		0x5c,0x51,0x33,0x00,0x58,0x4c,0x2e,0x00,0x56,0x4a,0x2a,0x00,0x53,0x48,0x26,0x00,0x50,0x45,0x21,0x00,0x4a,0x3d,0x17,0x00,
+		0x41,0x34,0x0c,0x00,0x3e,0x2e,0x05,0x00,0x3d,0x2d,0x01,0x00,0x3c,0x2d,0x00,0x00,0x3d,0x2c,0x00,0x00,0x3e,0x2d,0x00,0x00,
+		0x3f,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,
+		0x3c,0x2d,0x00,0x00,0x3a,0x2b,0x00,0x00,0x39,0x2a,0x00,0x00,0x37,0x29,0x00,0x00,0x35,0x27,0x00,0x00,0x33,0x26,0x00,0x00,
+		0x31,0x25,0x00,0x00,0x2f,0x23,0x00,0x00,0x2c,0x21,0x00,0x00,0x2a,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x24,0x1b,0x00,0x00,
+		0x21,0x19,0x00,0x00,0x1e,0x16,0x00,0x00,0x1c,0x15,0x00,0x00,0x1a,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,
+		0x13,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x07,0x00,0x00,
+		0x08,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x06,0x04,0x07,0x00,0x08,0x05,0x09,0x00,
+		0x0a,0x06,0x0b,0x00,0x0d,0x07,0x0e,0x00,0x0f,0x09,0x10,0x00,0x11,0x09,0x13,0x00,0x14,0x0b,0x15,0x00,0x17,0x0d,0x19,0x00,
+		0x1b,0x0f,0x1c,0x00,0x1d,0x11,0x1f,0x00,0x22,0x13,0x23,0x00,0x26,0x15,0x28,0x00,0x29,0x17,0x2c,0x00,0x2e,0x1a,0x30,0x00,
+		0x33,0x1c,0x35,0x00,0x36,0x1e,0x38,0x00,0x3b,0x21,0x3c,0x00,0x3f,0x23,0x40,0x00,0x43,0x26,0x44,0x00,0x47,0x28,0x47,0x00,
+		0x4b,0x2b,0x4b,0x00,0x4f,0x2e,0x4f,0x00,0x53,0x30,0x51,0x00,0x58,0x34,0x55,0x00,0x5d,0x39,0x5a,0x00,0x64,0x3f,0x60,0x00,
+		0x6d,0x47,0x66,0x00,0x76,0x50,0x6e,0x00,0x80,0x5b,0x78,0x00,0x8d,0x66,0x82,0x00,0x99,0x72,0x8c,0x00,0xa4,0x7d,0x94,0x00,
+		0xad,0x87,0x9b,0x00,0xb2,0x8e,0x9e,0x00,0xba,0x95,0xa4,0x00,0xbe,0x9b,0xa7,0x00,0xc1,0x9e,0xa7,0x00,0xfc,0xf3,0xfd,0x00,
+		0xd8,0x55,0xf5,0x00,0xcf,0x2f,0xf3,0x00,0xd1,0x38,0xf3,0x00,0xcf,0x37,0xf2,0x00,0xce,0x33,0xf1,0x00,0xcc,0x29,0xf2,0x00,
+		0xd1,0x3b,0xf2,0x00,0xe5,0x92,0xf9,0x00,0xfa,0xed,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xf9,0xd2,0x00,0xff,0xed,0x96,0x00,
+		0xff,0xe7,0x7a,0x00,0xff,0xe6,0x7c,0x00,0xff,0xe5,0x7b,0x00,0xff,0xe3,0x76,0x00,0xff,0xe1,0x73,0x00,0xff,0xdf,0x6f,0x00,
+		0xff,0xdd,0x6b,0x00,0xff,0xdb,0x66,0x00,0xff,0xda,0x62,0x00,0xff,0xd8,0x5f,0x00,0xff,0xd6,0x5a,0x00,0xff,0xd3,0x56,0x00,
+		0xff,0xd3,0x57,0x00,0xff,0xc7,0x31,0x00,0xff,0xac,0x21,0x00,0xff,0xac,0x2e,0x00,0xff,0xad,0x2f,0x00,0xff,0xae,0x31,0x00,
+		0xff,0xb0,0x34,0x00,0xff,0xb1,0x37,0x00,0xff,0xb2,0x39,0x00,0xff,0xb4,0x3b,0x00,0xff,0xb5,0x3d,0x00,0xff,0xb6,0x3f,0x00,
+		0xff,0xb7,0x42,0x00,0xff,0xb7,0x42,0x00,0xff,0xb5,0x3a,0x00,0xff,0xbb,0x4a,0x00,0xff,0xd9,0x99,0x00,0xff,0xf9,0xef,0x00,
+		0xff,0xff,0xff,0x00,0xca,0xf8,0xe9,0x00,0x78,0xea,0xbe,0x00,0x52,0xe3,0xac,0x00,0x57,0xe5,0xb0,0x00,0x60,0xe7,0xb4,0x00,
+		0x62,0xe7,0xb5,0x00,0x64,0xe8,0xb8,0x00,0x5d,0xe7,0xb4,0x00,0xa4,0xf1,0xd5,0x00,0xf6,0xf8,0xf7,0x00,0xb0,0xbc,0xb5,0x00,
+		0xa0,0xad,0xa6,0x00,0x9f,0xab,0xa5,0x00,0x9f,0xaa,0xa4,0x00,0x9e,0xa7,0xa3,0x00,0x9e,0xa5,0xa1,0x00,0x9c,0xa3,0xa0,0x00,
+		0x9b,0xa1,0x9f,0x00,0x9b,0x9f,0x9d,0x00,0x9a,0x9e,0x9c,0x00,0x9a,0x9d,0x9b,0x00,0xce,0xcf,0xcf,0x00,0xe2,0xe3,0xe3,0x00,
+		0x65,0x68,0x6a,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x99,0x9b,0x9d,0x00,0xd3,0xd4,0xd5,0x00,
+		0x8f,0x90,0x91,0x00,0xc2,0xc3,0xc3,0x00,0xc6,0xc7,0xc7,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x4a,0x4d,0x50,0x00,0x52,0x55,0x57,0x00,0x65,0x67,0x6a,0x00,0xc5,0xc5,0xc7,0x00,
+		0xeb,0xeb,0xeb,0x00,0xac,0xac,0xad,0x00,0x9d,0x9d,0x9e,0x00,0x9d,0x9d,0x9d,0x00,0xc1,0xc1,0xc0,0x00,0xf6,0xeb,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xae,0xac,0xa6,0x00,0xa6,0xa4,0x9c,0x00,0xa8,0xa6,0x9b,0x00,0xaa,0xa6,0x9b,0x00,
+		0xb3,0xaf,0xa4,0x00,0xe0,0xde,0xd9,0x00,0xf6,0xf2,0xe5,0x00,0xfc,0xde,0x86,0x00,0xff,0xc9,0x2c,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xe5,0xa4,0x00,
+		0xea,0xe1,0xca,0x00,0xc5,0xb8,0x91,0x00,0xc5,0xb8,0x91,0x00,0xee,0xe6,0xd2,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,
+		0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc5,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfe,0xc5,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfd,0xc5,0x26,0x00,
+		0xfe,0xc5,0x26,0x00,0xfd,0xc4,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfc,0xc5,0x26,0x00,0xfd,0xc6,0x28,0x00,0xf9,0xeb,0xc4,0x00,
+		0xd7,0xd2,0xc1,0x00,0xb6,0xac,0x8e,0x00,0xb0,0xa6,0x88,0x00,0xa9,0x9f,0x81,0x00,0x9e,0x93,0x77,0x00,0x92,0x88,0x6a,0x00,
+		0x85,0x7b,0x5d,0x00,0x79,0x6f,0x51,0x00,0x6d,0x63,0x44,0x00,0x65,0x5a,0x3b,0x00,0x5d,0x52,0x33,0x00,0x58,0x4c,0x2d,0x00,
+		0x53,0x46,0x25,0x00,0x4a,0x3e,0x19,0x00,0x41,0x34,0x0d,0x00,0x3c,0x2c,0x04,0x00,0x3c,0x2c,0x01,0x00,0x3c,0x2d,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3f,0x2e,0x00,0x00,0x3f,0x2e,0x00,0x00,0x41,0x2f,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x41,0x2f,0x00,0x00,0x40,0x30,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3c,0x2d,0x00,0x00,
+		0x3b,0x2b,0x00,0x00,0x39,0x2b,0x00,0x00,0x36,0x28,0x00,0x00,0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x2f,0x23,0x00,0x00,
+		0x2e,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x28,0x1e,0x00,0x00,0x25,0x1b,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,
+		0x1c,0x15,0x00,0x00,0x1a,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,
+		0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x06,0x04,0x07,0x00,0x08,0x05,0x09,0x00,0x0a,0x07,0x0b,0x00,0x0c,0x07,0x0d,0x00,
+		0x0f,0x08,0x10,0x00,0x11,0x09,0x13,0x00,0x14,0x0b,0x16,0x00,0x16,0x0c,0x18,0x00,0x1b,0x0e,0x1c,0x00,0x1f,0x10,0x21,0x00,
+		0x21,0x12,0x24,0x00,0x26,0x14,0x29,0x00,0x29,0x16,0x2c,0x00,0x2d,0x18,0x30,0x00,0x32,0x1b,0x35,0x00,0x37,0x1e,0x3a,0x00,
+		0x3b,0x20,0x3d,0x00,0x3e,0x22,0x41,0x00,0x43,0x24,0x45,0x00,0x47,0x27,0x49,0x00,0x4b,0x29,0x4c,0x00,0x4f,0x2c,0x50,0x00,
+		0x53,0x2f,0x53,0x00,0x58,0x33,0x57,0x00,0x5d,0x37,0x5b,0x00,0x65,0x3e,0x62,0x00,0x6d,0x45,0x68,0x00,0x76,0x4e,0x70,0x00,
+		0x80,0x59,0x79,0x00,0x8b,0x64,0x82,0x00,0x97,0x6e,0x8c,0x00,0xa2,0x7a,0x95,0x00,0xac,0x85,0x9d,0x00,0xb0,0x8a,0xa0,0x00,
+		0xb9,0x93,0xa6,0x00,0xbd,0x98,0xa9,0x00,0xc0,0x9c,0xa9,0x00,0xfc,0xf3,0xfd,0x00,0xd7,0x54,0xf5,0x00,0xcd,0x2f,0xf1,0x00,
+		0xce,0x37,0xf1,0x00,0xce,0x36,0xf1,0x00,0xce,0x36,0xf1,0x00,0xce,0x37,0xf2,0x00,0xcd,0x32,0xf2,0x00,0xca,0x28,0xf0,0x00,
+		0xd4,0x51,0xf3,0x00,0xec,0xb2,0xfa,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xf4,0x00,0xff,0xf4,0xbb,0x00,0xff,0xe7,0x82,0x00,
+		0xff,0xe2,0x71,0x00,0xff,0xe1,0x74,0x00,0xff,0xe1,0x73,0x00,0xff,0xde,0x6e,0x00,0xff,0xdd,0x6a,0x00,0xff,0xdc,0x66,0x00,
+		0xff,0xd9,0x62,0x00,0xff,0xd7,0x5e,0x00,0xff,0xd5,0x59,0x00,0xff,0xd3,0x55,0x00,0xff,0xd3,0x56,0x00,0xff,0xc8,0x30,0x00,
+		0xff,0xaa,0x1f,0x00,0xff,0xaa,0x2c,0x00,0xff,0xac,0x2d,0x00,0xff,0xad,0x2f,0x00,0xff,0xaf,0x32,0x00,0xff,0xb0,0x35,0x00,
+		0xff,0xb1,0x37,0x00,0xff,0xb2,0x39,0x00,0xff,0xb3,0x3c,0x00,0xff,0xb5,0x3d,0x00,0xff,0xb1,0x34,0x00,0xff,0xb4,0x3b,0x00,
+		0xff,0xce,0x7c,0x00,0xff,0xf1,0xdb,0x00,0xff,0xff,0xff,0x00,0xde,0xfa,0xf1,0x00,0x88,0xec,0xc5,0x00,0x52,0xe3,0xaa,0x00,
+		0x51,0xe3,0xaa,0x00,0x5b,0xe5,0xb0,0x00,0x5c,0xe5,0xb1,0x00,0x5e,0xe6,0xb3,0x00,0x61,0xe6,0xb4,0x00,0x63,0xe7,0xb6,0x00,
+		0x5a,0xe6,0xb3,0x00,0xa3,0xf0,0xd4,0x00,0xf6,0xf8,0xf7,0x00,0xb0,0xbc,0xb6,0x00,0xa0,0xae,0xa7,0x00,0x9f,0xab,0xa5,0x00,
+		0x9f,0xaa,0xa4,0x00,0x9e,0xa8,0xa3,0x00,0x9e,0xa6,0xa2,0x00,0x9d,0xa5,0xa2,0x00,0x9d,0xa3,0xa0,0x00,0x9c,0xa1,0x9f,0x00,
+		0x9b,0x9f,0x9e,0x00,0xa9,0xac,0xab,0x00,0xea,0xea,0xea,0x00,0x9c,0x9d,0xa0,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4a,0x4e,0x00,
+		0x5a,0x5c,0x60,0x00,0x58,0x5a,0x5e,0x00,0x4a,0x4c,0x50,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x9e,0x9f,0xa2,0x00,0xd2,0xd2,0xd3,0x00,0x8e,0x8f,0x90,0x00,0xc2,0xc2,0xc3,0x00,
+		0xc6,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x55,0x57,0x5a,0x00,0x69,0x6b,0x6e,0x00,0x68,0x6a,0x6d,0x00,0x6a,0x6c,0x6f,0x00,
+		0x5c,0x5e,0x61,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4b,0x4e,0x00,0x4c,0x4e,0x52,0x00,
+		0x56,0x58,0x5c,0x00,0x60,0x61,0x65,0x00,0x62,0x64,0x68,0x00,0x75,0x77,0x7a,0x00,0xe3,0xe4,0xe4,0x00,0xcf,0xcf,0xd0,0x00,
+		0x9c,0x9c,0x9d,0x00,0x9c,0x9d,0x9d,0x00,0xc1,0xc0,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,
+		0xae,0xac,0xa6,0x00,0xa7,0xa5,0x9c,0x00,0xa9,0xa6,0x9b,0x00,0xb1,0xad,0xa3,0x00,0xe3,0xe1,0xdc,0x00,0xf7,0xf1,0xdf,0x00,
+		0xff,0xd6,0x62,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xe6,0xa7,0x00,0xea,0xe1,0xc9,0x00,0xc6,0xb8,0x90,0x00,
+		0xc5,0xb7,0x8f,0x00,0xef,0xe7,0xd2,0x00,0xfd,0xe1,0x92,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfe,0xc6,0x2a,0x00,0xfe,0xc8,0x2b,0x00,
+		0xfe,0xc7,0x2a,0x00,0xfd,0xc6,0x2a,0x00,0xfd,0xc6,0x2a,0x00,0xfe,0xc6,0x2a,0x00,0xfd,0xc6,0x2a,0x00,0xfe,0xc7,0x2a,0x00,
+		0xfc,0xc5,0x2a,0x00,0xfc,0xc6,0x2a,0x00,0xfd,0xc7,0x2c,0x00,0xf9,0xea,0xc3,0x00,0xd7,0xd2,0xc1,0x00,0xb7,0xac,0x8f,0x00,
+		0xb0,0xa6,0x88,0x00,0xa9,0x9f,0x81,0x00,0x9e,0x93,0x77,0x00,0x93,0x88,0x6b,0x00,0x85,0x7c,0x5d,0x00,0x7a,0x6f,0x51,0x00,
+		0x6f,0x64,0x45,0x00,0x64,0x59,0x3a,0x00,0x5b,0x4f,0x2f,0x00,0x4f,0x42,0x20,0x00,0x43,0x36,0x11,0x00,0x3c,0x2e,0x06,0x00,
+		0x3b,0x2c,0x02,0x00,0x3a,0x2b,0x00,0x00,0x3b,0x2c,0x00,0x00,0x3d,0x2c,0x00,0x00,0x3f,0x2f,0x00,0x00,0x40,0x30,0x00,0x00,
+		0x41,0x2f,0x00,0x00,0x42,0x30,0x00,0x00,0x43,0x31,0x00,0x00,0x42,0x31,0x00,0x00,0x42,0x31,0x00,0x00,0x42,0x31,0x00,0x00,
+		0x41,0x30,0x00,0x00,0x40,0x30,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3c,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,
+		0x38,0x2a,0x00,0x00,0x35,0x27,0x00,0x00,0x33,0x26,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2c,0x21,0x00,0x00,
+		0x29,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1b,0x13,0x00,0x00,
+		0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x14,0x0f,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,
+		0x07,0x05,0x07,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x07,0x0d,0x00,0x0f,0x07,0x10,0x00,0x11,0x09,0x13,0x00,
+		0x14,0x0a,0x17,0x00,0x16,0x0c,0x18,0x00,0x1b,0x0e,0x1c,0x00,0x1e,0x10,0x21,0x00,0x21,0x11,0x24,0x00,0x25,0x14,0x29,0x00,
+		0x2a,0x16,0x2c,0x00,0x2e,0x18,0x31,0x00,0x32,0x1a,0x35,0x00,0x36,0x1c,0x3a,0x00,0x3a,0x1e,0x3e,0x00,0x3f,0x21,0x42,0x00,
+		0x43,0x23,0x46,0x00,0x47,0x25,0x4a,0x00,0x4a,0x27,0x4d,0x00,0x4f,0x2a,0x51,0x00,0x53,0x2d,0x54,0x00,0x58,0x30,0x59,0x00,
+		0x5d,0x34,0x5d,0x00,0x64,0x3b,0x63,0x00,0x6b,0x42,0x68,0x00,0x76,0x4c,0x72,0x00,0x80,0x56,0x7b,0x00,0x8a,0x61,0x83,0x00,
+		0x96,0x6c,0x8e,0x00,0xa1,0x77,0x97,0x00,0xab,0x82,0x9f,0x00,0xb2,0x8a,0xa4,0x00,0xb7,0x8f,0xa7,0x00,0xbc,0x95,0xaa,0x00,
+		0xc0,0x9a,0xac,0x00,0xfb,0xf3,0xfd,0x00,0xd6,0x54,0xf4,0x00,0xcb,0x2e,0xf0,0x00,0xcd,0x36,0xf1,0x00,0xce,0x36,0xf2,0x00,
+		0xcd,0x36,0xf2,0x00,0xcc,0x36,0xf1,0x00,0xcd,0x36,0xf2,0x00,0xcc,0x36,0xf1,0x00,0xca,0x2c,0xf0,0x00,0xc9,0x2c,0xf0,0x00,
+		0xd9,0x69,0xf5,0x00,0xf3,0xd0,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xfe,0xe7,0x00,0xff,0xed,0xa3,0x00,0xff,0xe1,0x72,0x00,
+		0xff,0xdf,0x6b,0x00,0xff,0xdf,0x6e,0x00,0xff,0xdd,0x6a,0x00,0xff,0xdb,0x66,0x00,0xff,0xd9,0x62,0x00,0xff,0xd7,0x5e,0x00,
+		0xff,0xd5,0x59,0x00,0xff,0xd3,0x55,0x00,0xff,0xd3,0x56,0x00,0xff,0xc7,0x30,0x00,0xff,0xa9,0x1d,0x00,0xff,0xa9,0x29,0x00,
+		0xff,0xab,0x2b,0x00,0xff,0xad,0x2d,0x00,0xff,0xad,0x2f,0x00,0xff,0xaf,0x32,0x00,0xff,0xb0,0x34,0x00,0xff,0xb1,0x37,0x00,
+		0xff,0xaf,0x32,0x00,0xff,0xae,0x2e,0x00,0xff,0xc2,0x62,0x00,0xff,0xe6,0xc1,0x00,0xff,0xff,0xff,0x00,0xea,0xfe,0xfc,0x00,
+		0x9c,0xef,0xcf,0x00,0x55,0xe3,0xaa,0x00,0x47,0xe1,0xa4,0x00,0x53,0xe3,0xaa,0x00,0x58,0xe4,0xae,0x00,0x59,0xe5,0xaf,0x00,
+		0x5b,0xe4,0xb0,0x00,0x5d,0xe6,0xb1,0x00,0x5e,0xe6,0xb3,0x00,0x61,0xe6,0xb4,0x00,0x58,0xe5,0xb1,0x00,0xa2,0xf0,0xd4,0x00,
+		0xf6,0xf8,0xf7,0x00,0xaf,0xbc,0xb5,0x00,0x9f,0xae,0xa7,0x00,0x9f,0xac,0xa6,0x00,0x9e,0xaa,0xa4,0x00,0x9d,0xa8,0xa3,0x00,
+		0x9e,0xa6,0xa3,0x00,0x9d,0xa4,0xa1,0x00,0x9c,0xa3,0xa0,0x00,0x9b,0xa1,0x9f,0x00,0x9a,0x9f,0x9d,0x00,0xbc,0xbe,0xbe,0x00,
+		0xdf,0xe0,0xe0,0x00,0x65,0x67,0x6a,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x69,0x6b,0x6e,0x00,0xbe,0xbf,0xc0,0x00,0xe3,0xe4,0xe4,0x00,0xe3,0xe3,0xe3,0x00,
+		0xc7,0xc8,0xc9,0x00,0xaa,0xab,0xac,0x00,0x8a,0x8b,0x8e,0x00,0x67,0x68,0x6c,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x9e,0xa0,0xa2,0x00,0xd2,0xd2,0xd3,0x00,0x8d,0x8e,0x90,0x00,0xc1,0xc2,0xc3,0x00,0xc6,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x58,0x5a,0x5e,0x00,
+		0xbb,0xbb,0xbd,0x00,0xe3,0xe3,0xe4,0x00,0xe0,0xe0,0xe0,0x00,0xe3,0xe3,0xe4,0x00,0xe0,0xe0,0xe1,0x00,0xb3,0xb4,0xb5,0x00,
+		0x62,0x64,0x67,0x00,0x4a,0x4c,0x50,0x00,0x51,0x53,0x57,0x00,0x5c,0x5f,0x61,0x00,0x62,0x63,0x67,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0xb4,0xb6,0xb7,0x00,0xe3,0xe4,0xe4,0x00,0xa4,0xa4,0xa5,0x00,0x9c,0x9c,0x9c,0x00,
+		0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xae,0xac,0xa6,0x00,0xa7,0xa4,0x9b,0x00,
+		0xa8,0xa5,0x9b,0x00,0xcc,0xc9,0xc2,0x00,0xf7,0xf2,0xe5,0x00,0xff,0xd4,0x58,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xca,0x34,0x00,0xff,0xd1,0x4c,0x00,0xff,0xd9,0x6a,0x00,0xfe,0xdf,0x86,0x00,
+		0xff,0xdb,0x75,0x00,0xff,0xd5,0x5e,0x00,0xff,0xce,0x42,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfc,0xe6,0xa6,0x00,0xea,0xe1,0xc9,0x00,0xc7,0xb8,0x8e,0x00,0xc7,0xb8,0x8e,0x00,0xef,0xe7,0xd2,0x00,
+		0xfc,0xe0,0x91,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc5,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfd,0xd0,0x51,0x00,0xfa,0xe7,0xb4,0x00,0xfa,0xec,0xc6,0x00,0xfa,0xec,0xc4,0x00,0xfa,0xec,0xc4,0x00,
+		0xf9,0xeb,0xc3,0x00,0xfa,0xec,0xc4,0x00,0xf9,0xeb,0xc3,0x00,0xf9,0xeb,0xc3,0x00,0xfa,0xec,0xc4,0x00,0xf7,0xe9,0xc2,0x00,
+		0xf9,0xea,0xc1,0x00,0xf9,0xf2,0xdf,0x00,0xd7,0xd2,0xc2,0x00,0xb7,0xac,0x8f,0x00,0xaf,0xa5,0x89,0x00,0xa9,0x9f,0x82,0x00,
+		0x9d,0x93,0x76,0x00,0x92,0x87,0x6a,0x00,0x86,0x7b,0x5e,0x00,0x79,0x6e,0x4f,0x00,0x6c,0x60,0x41,0x00,0x5c,0x4f,0x2e,0x00,
+		0x4b,0x3e,0x1a,0x00,0x3f,0x32,0x0c,0x00,0x3d,0x2f,0x06,0x00,0x39,0x2c,0x02,0x00,0x3b,0x2b,0x01,0x00,0x3c,0x2c,0x00,0x00,
+		0x3d,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,0x40,0x30,0x00,0x00,0x41,0x2f,0x00,0x00,0x43,0x31,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x44,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x42,0x31,0x00,0x00,
+		0x40,0x2f,0x00,0x00,0x40,0x2f,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3b,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,0x36,0x28,0x00,0x00,
+		0x35,0x28,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2d,0x21,0x00,0x00,0x29,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,
+		0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,0x1e,0x16,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,0x16,0x11,0x00,0x00,
+		0x14,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x07,0x05,0x08,0x00,0x08,0x05,0x09,0x00,
+		0x0a,0x06,0x0b,0x00,0x0c,0x06,0x0d,0x00,0x0f,0x07,0x10,0x00,0x11,0x09,0x14,0x00,0x14,0x0a,0x17,0x00,0x17,0x0c,0x19,0x00,
+		0x1b,0x0e,0x1d,0x00,0x1d,0x0f,0x20,0x00,0x23,0x11,0x25,0x00,0x26,0x13,0x29,0x00,0x29,0x15,0x2d,0x00,0x2d,0x17,0x31,0x00,
+		0x32,0x1a,0x36,0x00,0x37,0x1c,0x3b,0x00,0x3b,0x1d,0x3f,0x00,0x3e,0x1f,0x43,0x00,0x42,0x22,0x47,0x00,0x47,0x24,0x4b,0x00,
+		0x4a,0x25,0x4e,0x00,0x4f,0x29,0x52,0x00,0x53,0x2b,0x56,0x00,0x57,0x2f,0x5a,0x00,0x5c,0x32,0x5d,0x00,0x63,0x39,0x63,0x00,
+		0x6b,0x40,0x6b,0x00,0x74,0x49,0x72,0x00,0x7f,0x53,0x7c,0x00,0x8a,0x5f,0x85,0x00,0x96,0x6a,0x90,0x00,0x9e,0x74,0x97,0x00,
+		0xaa,0x7f,0xa1,0x00,0xb1,0x87,0xa6,0x00,0xb7,0x8e,0xaa,0x00,0xbb,0x93,0xac,0x00,0xbe,0x97,0xad,0x00,0xfa,0xf2,0xfc,0x00,
+		0xd3,0x53,0xf2,0x00,0xca,0x2e,0xf0,0x00,0xcb,0x37,0xf0,0x00,0xcb,0x35,0xf0,0x00,0xcc,0x36,0xf1,0x00,0xcc,0x36,0xf1,0x00,
+		0xcc,0x36,0xf1,0x00,0xca,0x36,0xf0,0x00,0xcb,0x36,0xf1,0x00,0xcb,0x35,0xf0,0x00,0xc8,0x29,0xef,0x00,0xcb,0x36,0xf0,0x00,
+		0xe0,0x87,0xf6,0x00,0xf9,0xe8,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xfa,0xd4,0x00,0xff,0xe5,0x89,0x00,0xff,0xdc,0x65,0x00,
+		0xff,0xdb,0x64,0x00,0xff,0xdb,0x66,0x00,0xff,0xd8,0x61,0x00,0xff,0xd6,0x5d,0x00,0xff,0xd5,0x59,0x00,0xff,0xd3,0x55,0x00,
+		0xff,0xd3,0x55,0x00,0xff,0xc7,0x30,0x00,0xff,0xa8,0x1b,0x00,0xff,0xa7,0x26,0x00,0xff,0xa9,0x29,0x00,0xff,0xab,0x2b,0x00,
+		0xff,0xac,0x2d,0x00,0xff,0xae,0x30,0x00,0xff,0xac,0x2d,0x00,0xff,0xaa,0x26,0x00,0xff,0xb7,0x47,0x00,0xff,0xdd,0xa7,0x00,
+		0xff,0xfc,0xf8,0x00,0xfc,0xff,0xff,0x00,0xb1,0xf3,0xd8,0x00,0x5c,0xe4,0xad,0x00,0x40,0xdf,0xa0,0x00,0x4b,0xe1,0xa5,0x00,
+		0x52,0xe2,0xa8,0x00,0x53,0xe3,0xaa,0x00,0x54,0xe3,0xab,0x00,0x56,0xe4,0xad,0x00,0x59,0xe4,0xaf,0x00,0x5b,0xe5,0xb0,0x00,
+		0x5c,0xe5,0xb1,0x00,0x5f,0xe6,0xb3,0x00,0x56,0xe5,0xaf,0x00,0xa0,0xf1,0xd2,0x00,0xf6,0xf8,0xf7,0x00,0xae,0xbd,0xb5,0x00,
+		0x9e,0xae,0xa6,0x00,0x9e,0xac,0xa6,0x00,0x9e,0xaa,0xa5,0x00,0x9e,0xa9,0xa4,0x00,0x9e,0xa7,0xa3,0x00,0x9e,0xa5,0xa2,0x00,
+		0x9d,0xa4,0xa1,0x00,0x9c,0xa2,0xa0,0x00,0x9b,0xa0,0x9e,0x00,0xc6,0xc9,0xc8,0x00,0xd5,0xd5,0xd6,0x00,0x53,0x55,0x59,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x67,0x6a,0x6c,0x00,
+		0xd6,0xd7,0xd8,0x00,0xda,0xdb,0xdb,0x00,0xbb,0xbc,0xbd,0x00,0xb8,0xb8,0xb9,0x00,0xca,0xcb,0xcb,0x00,0xda,0xdb,0xdb,0x00,
+		0xe9,0xe9,0xe9,0x00,0xe2,0xe2,0xe3,0x00,0xa4,0xa5,0xa7,0x00,0x55,0x57,0x5b,0x00,0x99,0x9a,0x9c,0x00,0xd2,0xd2,0xd3,0x00,
+		0x8d,0x8e,0x8f,0x00,0xc1,0xc2,0xc2,0x00,0xc6,0xc6,0xc7,0x00,0x47,0x49,0x4c,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x77,0x7a,0x7c,0x00,0xe1,0xe1,0xe2,0x00,0xb1,0xb2,0xb3,0x00,
+		0xa0,0xa1,0xa2,0x00,0xa4,0xa4,0xa5,0x00,0xbc,0xbd,0xbe,0x00,0xe2,0xe2,0xe3,0x00,0xd9,0xd9,0xda,0x00,0x72,0x73,0x76,0x00,
+		0x60,0x61,0x65,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x90,0x92,0x94,0x00,0xe8,0xe8,0xe9,0x00,0xac,0xac,0xac,0x00,0x9c,0x9c,0x9c,0x00,0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xae,0xac,0xa5,0x00,0xa6,0xa4,0x9b,0x00,0xaf,0xab,0xa1,0x00,0xec,0xeb,0xe5,0x00,
+		0xfa,0xe6,0xad,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xd2,0x52,0x00,0xfc,0xe7,0xaa,0x00,
+		0xfb,0xee,0xcc,0x00,0xf9,0xf1,0xdb,0x00,0xf8,0xf3,0xe5,0x00,0xf5,0xf1,0xe2,0x00,0xf6,0xf1,0xe3,0x00,0xf9,0xf3,0xe4,0x00,
+		0xfa,0xf1,0xd7,0x00,0xfc,0xeb,0xb8,0x00,0xff,0xd7,0x68,0x00,0xff,0xc7,0x28,0x00,0xff,0xc7,0x26,0x00,0xfc,0xe5,0xa6,0x00,
+		0xea,0xe1,0xc8,0x00,0xc8,0xb8,0x8d,0x00,0xc8,0xb8,0x8d,0x00,0xf0,0xe7,0xd2,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xfc,0xe7,0xae,0x00,
+		0xec,0xe6,0xd5,0x00,0xdd,0xd4,0xbd,0x00,0xdd,0xd5,0xbe,0x00,0xde,0xd5,0xbe,0x00,0xdd,0xd5,0xbf,0x00,0xdd,0xd5,0xbf,0x00,
+		0xde,0xd6,0xc1,0x00,0xdc,0xd4,0xc0,0x00,0xdc,0xd5,0xc0,0x00,0xdb,0xd5,0xc0,0x00,0xdb,0xd4,0xc0,0x00,0xd8,0xd2,0xbf,0x00,
+		0xc7,0xbf,0xa7,0x00,0xb6,0xab,0x8e,0x00,0xb0,0xa6,0x89,0x00,0xa7,0x9d,0x80,0x00,0x9d,0x93,0x77,0x00,0x91,0x88,0x69,0x00,
+		0x83,0x78,0x5a,0x00,0x71,0x65,0x45,0x00,0x5c,0x50,0x2d,0x00,0x4d,0x41,0x1c,0x00,0x44,0x37,0x11,0x00,0x3e,0x30,0x09,0x00,
+		0x3c,0x2e,0x05,0x00,0x3b,0x2c,0x02,0x00,0x3b,0x2c,0x01,0x00,0x3c,0x2d,0x00,0x00,0x3e,0x2e,0x00,0x00,0x40,0x30,0x00,0x00,
+		0x41,0x30,0x00,0x00,0x43,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x45,0x33,0x00,0x00,0x45,0x33,0x00,0x00,0x45,0x33,0x00,0x00,
+		0x45,0x33,0x00,0x00,0x45,0x33,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x3e,0x2e,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3b,0x2b,0x00,0x00,0x39,0x2a,0x00,0x00,0x36,0x28,0x00,0x00,0x32,0x25,0x00,0x00,
+		0x2f,0x23,0x00,0x00,0x2e,0x22,0x00,0x00,0x2a,0x1f,0x00,0x00,0x28,0x1d,0x00,0x00,0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,
+		0x1e,0x16,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x14,0x0e,0x00,0x00,0x12,0x0e,0x00,0x00,
+		0x0f,0x0c,0x00,0x00,0x0d,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x02,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,
+		0x05,0x02,0x06,0x00,0x06,0x04,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x07,0x0e,0x00,
+		0x0f,0x07,0x10,0x00,0x11,0x09,0x14,0x00,0x14,0x0a,0x17,0x00,0x18,0x0c,0x1a,0x00,0x1a,0x0d,0x1d,0x00,0x1e,0x0f,0x21,0x00,
+		0x22,0x11,0x25,0x00,0x26,0x13,0x29,0x00,0x29,0x14,0x2d,0x00,0x2e,0x17,0x32,0x00,0x32,0x19,0x37,0x00,0x36,0x1b,0x3b,0x00,
+		0x3a,0x1c,0x40,0x00,0x3d,0x1e,0x43,0x00,0x43,0x20,0x48,0x00,0x46,0x22,0x4b,0x00,0x4a,0x24,0x4e,0x00,0x4e,0x27,0x53,0x00,
+		0x52,0x2a,0x57,0x00,0x57,0x2d,0x5a,0x00,0x5b,0x31,0x5e,0x00,0x62,0x37,0x64,0x00,0x6a,0x3e,0x6c,0x00,0x74,0x47,0x74,0x00,
+		0x7d,0x50,0x7c,0x00,0x8a,0x5c,0x87,0x00,0x92,0x67,0x90,0x00,0x9f,0x73,0x9a,0x00,0xa9,0x7c,0xa2,0x00,0xb0,0x84,0xa8,0x00,
+		0xb5,0x8a,0xab,0x00,0xba,0x90,0xae,0x00,0xbd,0x94,0xaf,0x00,0xfa,0xf2,0xfc,0x00,0xd3,0x54,0xf2,0x00,0xca,0x2e,0xf0,0x00,
+		0xcb,0x37,0xf0,0x00,0xca,0x35,0xf0,0x00,0xca,0x36,0xf0,0x00,0xcb,0x36,0xf1,0x00,0xcb,0x36,0xf1,0x00,0xcb,0x36,0xf0,0x00,
+		0xcb,0x36,0xf0,0x00,0xca,0x35,0xf0,0x00,0xca,0x36,0xf0,0x00,0xc8,0x31,0xef,0x00,0xc5,0x27,0xee,0x00,0xcd,0x44,0xf1,0x00,
+		0xe7,0xa7,0xfa,0x00,0xfd,0xf7,0xff,0x00,0xff,0xff,0xf9,0x00,0xff,0xf1,0xbb,0x00,0xff,0xdf,0x73,0x00,0xff,0xd8,0x5b,0x00,
+		0xff,0xd8,0x5f,0x00,0xff,0xd7,0x5d,0x00,0xff,0xd4,0x58,0x00,0xff,0xd2,0x54,0x00,0xff,0xd2,0x55,0x00,0xff,0xc6,0x2f,0x00,
+		0xff,0xa7,0x17,0x00,0xff,0xa7,0x23,0x00,0xff,0xa8,0x25,0x00,0xff,0xa9,0x29,0x00,0xff,0xaa,0x29,0x00,0xff,0xa7,0x1f,0x00,
+		0xff,0xae,0x31,0x00,0xff,0xcf,0x87,0x00,0xff,0xf6,0xea,0x00,0xff,0xff,0xff,0x00,0xc8,0xf7,0xe6,0x00,0x6b,0xe6,0xb3,0x00,
+		0x3b,0xdf,0x9c,0x00,0x41,0xe0,0x9f,0x00,0x4b,0xe1,0xa4,0x00,0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,0x51,0xe3,0xa9,0x00,
+		0x53,0xe3,0xaa,0x00,0x55,0xe3,0xac,0x00,0x56,0xe4,0xad,0x00,0x59,0xe4,0xaf,0x00,0x5a,0xe4,0xb0,0x00,0x5d,0xe6,0xb1,0x00,
+		0x54,0xe4,0xae,0x00,0x9f,0xf0,0xd1,0x00,0xf6,0xf8,0xf7,0x00,0xad,0xbd,0xb5,0x00,0x9e,0xae,0xa7,0x00,0x9e,0xac,0xa6,0x00,
+		0x9e,0xab,0xa5,0x00,0x9e,0xa9,0xa4,0x00,0x9d,0xa7,0xa3,0x00,0x9d,0xa5,0xa2,0x00,0x9d,0xa3,0xa1,0x00,0x9c,0xa2,0xa0,0x00,
+		0x9b,0xa0,0x9e,0x00,0xc9,0xcb,0xcb,0x00,0xca,0xcb,0xcc,0x00,0x49,0x4b,0x4f,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x8d,0x8e,0x91,0x00,0xe9,0xe9,0xea,0x00,0xa6,0xa7,0xa8,0x00,
+		0x8f,0x90,0x90,0x00,0x8e,0x8f,0x8f,0x00,0x8e,0x8e,0x8f,0x00,0x8d,0x8e,0x90,0x00,0x9a,0x9b,0x9c,0x00,0xc3,0xc4,0xc4,0x00,
+		0xe6,0xe6,0xe7,0x00,0xd6,0xd7,0xd7,0x00,0xbf,0xbf,0xc1,0x00,0xd0,0xd1,0xd1,0x00,0x8d,0x8d,0x8e,0x00,0xc1,0xc1,0xc2,0x00,
+		0xc6,0xc6,0xc7,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x74,0x76,0x79,0x00,0xdb,0xdb,0xdc,0x00,0x9a,0x9b,0x9c,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,
+		0x8c,0x8c,0x8d,0x00,0x9d,0x9f,0x9f,0x00,0xe4,0xe4,0xe4,0x00,0xce,0xce,0xd0,0x00,0x6a,0x6c,0x6e,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x7c,0x7d,0x80,0x00,0xe6,0xe6,0xe6,0x00,
+		0xbc,0xbc,0xbc,0x00,0x9b,0x9c,0x9c,0x00,0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,
+		0xae,0xac,0xa5,0x00,0xa7,0xa4,0x9b,0x00,0xc5,0xc3,0xbc,0x00,0xf7,0xf2,0xe5,0x00,0xff,0xd3,0x56,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc8,0x29,0x00,0xfc,0xde,0x86,0x00,0xf9,0xf4,0xe4,0x00,0xf0,0xec,0xe0,0x00,0xe0,0xda,0xc7,0x00,0xd6,0xce,0xb3,0x00,
+		0xce,0xc2,0xa1,0x00,0xc7,0xba,0x92,0x00,0xc9,0xbc,0x95,0x00,0xd2,0xc6,0xa6,0x00,0xdf,0xd7,0xbe,0x00,0xee,0xe9,0xda,0x00,
+		0xf9,0xf4,0xe5,0x00,0xfc,0xea,0xb6,0x00,0xff,0xd4,0x57,0x00,0xfc,0xe5,0xa1,0x00,0xeb,0xe1,0xc8,0x00,0xc8,0xb8,0x8c,0x00,
+		0xc8,0xb8,0x8c,0x00,0xf0,0xe7,0xd1,0x00,0xfd,0xe1,0x92,0x00,0xfe,0xc5,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc5,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfb,0xea,0xb9,0x00,0xe3,0xda,0xc3,0x00,0xc4,0xb7,0x91,0x00,
+		0xc2,0xb7,0x92,0x00,0xc3,0xb7,0x93,0x00,0xc2,0xb7,0x94,0x00,0xc2,0xb7,0x94,0x00,0xc2,0xb6,0x95,0x00,0xc1,0xb7,0x96,0x00,
+		0xbf,0xb5,0x95,0x00,0xbf,0xb5,0x96,0x00,0xbf,0xb4,0x96,0x00,0xbc,0xb2,0x95,0x00,0xbb,0xb1,0x94,0x00,0xb5,0xaa,0x8e,0x00,
+		0xb0,0xa5,0x89,0x00,0xa7,0x9d,0x80,0x00,0x9b,0x90,0x73,0x00,0x8a,0x7f,0x60,0x00,0x76,0x69,0x48,0x00,0x64,0x58,0x34,0x00,
+		0x56,0x49,0x25,0x00,0x4a,0x3e,0x18,0x00,0x43,0x36,0x10,0x00,0x3f,0x31,0x09,0x00,0x3d,0x2e,0x05,0x00,0x3b,0x2d,0x02,0x00,
+		0x3c,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,0x3f,0x2f,0x00,0x00,0x41,0x2f,0x00,0x00,0x42,0x30,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x45,0x32,0x00,0x00,0x46,0x34,0x00,0x00,0x47,0x34,0x00,0x00,0x46,0x34,0x00,0x00,0x46,0x34,0x00,0x00,0x46,0x33,0x00,0x00,
+		0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x44,0x32,0x00,0x00,0x41,0x30,0x00,0x00,0x3f,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,
+		0x3c,0x2c,0x00,0x00,0x39,0x2a,0x00,0x00,0x37,0x28,0x00,0x00,0x34,0x26,0x00,0x00,0x30,0x24,0x00,0x00,0x2e,0x21,0x00,0x00,
+		0x2b,0x20,0x00,0x00,0x28,0x1e,0x00,0x00,0x25,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x19,0x13,0x00,0x00,0x16,0x11,0x00,0x00,0x14,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0b,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x02,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x02,0x06,0x00,0x06,0x04,0x06,0x00,
+		0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0f,0x07,0x11,0x00,0x11,0x08,0x14,0x00,
+		0x14,0x0a,0x16,0x00,0x17,0x0b,0x19,0x00,0x1a,0x0d,0x1d,0x00,0x1d,0x0f,0x21,0x00,0x21,0x10,0x25,0x00,0x25,0x12,0x29,0x00,
+		0x29,0x14,0x2e,0x00,0x2e,0x16,0x33,0x00,0x31,0x17,0x37,0x00,0x36,0x1a,0x3b,0x00,0x3a,0x1c,0x40,0x00,0x3e,0x1d,0x44,0x00,
+		0x42,0x1f,0x49,0x00,0x45,0x21,0x4b,0x00,0x4a,0x23,0x50,0x00,0x4e,0x25,0x53,0x00,0x52,0x28,0x57,0x00,0x56,0x2b,0x5b,0x00,
+		0x5a,0x2f,0x5e,0x00,0x63,0x35,0x67,0x00,0x6a,0x3c,0x6d,0x00,0x73,0x45,0x75,0x00,0x7d,0x4f,0x7e,0x00,0x88,0x5a,0x88,0x00,
+		0x93,0x66,0x92,0x00,0x9e,0x70,0x9b,0x00,0xa8,0x7b,0xa3,0x00,0xae,0x81,0xa8,0x00,0xb5,0x88,0xad,0x00,0xb9,0x8e,0xb0,0x00,
+		0xbc,0x92,0xb1,0x00,0xfb,0xf3,0xfd,0x00,0xd2,0x54,0xf2,0x00,0xc8,0x2e,0xef,0x00,0xcb,0x36,0xf0,0x00,0xc9,0x35,0xef,0x00,
+		0xc9,0x35,0xef,0x00,0xc9,0x35,0xef,0x00,0xc9,0x35,0xef,0x00,0xc9,0x35,0xf0,0x00,0xc9,0x35,0xef,0x00,0xc9,0x35,0xef,0x00,
+		0xc8,0x35,0xef,0x00,0xc8,0x35,0xef,0x00,0xc8,0x35,0xef,0x00,0xc5,0x2f,0xee,0x00,0xc4,0x29,0xee,0x00,0xd2,0x5d,0xf3,0x00,
+		0xee,0xc3,0xfd,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xea,0x00,0xff,0xe9,0x9f,0x00,0xff,0xd8,0x5e,0x00,0xff,0xd4,0x52,0x00,
+		0xff,0xd4,0x57,0x00,0xff,0xd2,0x55,0x00,0xff,0xd2,0x55,0x00,0xff,0xc6,0x2e,0x00,0xff,0xa5,0x14,0x00,0xff,0xa6,0x22,0x00,
+		0xff,0xa7,0x22,0x00,0xff,0xa4,0x19,0x00,0xff,0xa6,0x1f,0x00,0xff,0xc2,0x67,0x00,0xff,0xee,0xd6,0x00,0xff,0xff,0xff,0x00,
+		0xdb,0xfa,0xef,0x00,0x7e,0xe9,0xbc,0x00,0x3b,0xdf,0x9a,0x00,0x39,0xde,0x99,0x00,0x44,0xdf,0xa0,0x00,0x47,0xe1,0xa2,0x00,
+		0x49,0xe1,0xa3,0x00,0x4b,0xe2,0xa5,0x00,0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,0x51,0xe3,0xa9,0x00,0x53,0xe3,0xaa,0x00,
+		0x54,0xe3,0xab,0x00,0x57,0xe4,0xad,0x00,0x59,0xe4,0xae,0x00,0x5b,0xe5,0xb0,0x00,0x52,0xe4,0xac,0x00,0x9e,0xf0,0xd0,0x00,
+		0xf6,0xf8,0xf7,0x00,0xad,0xbd,0xb5,0x00,0x9d,0xae,0xa7,0x00,0x9d,0xac,0xa6,0x00,0x9d,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,
+		0x9d,0xa7,0xa3,0x00,0x9d,0xa6,0xa2,0x00,0x9d,0xa3,0xa1,0x00,0x9c,0xa1,0x9f,0x00,0x9b,0xa0,0x9e,0x00,0xc7,0xca,0xc9,0x00,
+		0xd2,0xd2,0xd3,0x00,0x50,0x52,0x55,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x5b,0x5e,0x61,0x00,0xd6,0xd7,0xd7,0x00,0xde,0xdf,0xdf,0x00,0xa7,0xa7,0xa8,0x00,0x8d,0x8e,0x8f,0x00,
+		0x8d,0x8e,0x8e,0x00,0x8d,0x8d,0x8e,0x00,0x8c,0x8d,0x8e,0x00,0x8c,0x8c,0x8e,0x00,0x9f,0x9f,0xa0,0x00,0xd1,0xd1,0xd1,0x00,
+		0xe1,0xe1,0xe1,0x00,0xca,0xca,0xca,0x00,0x8d,0x8e,0x8f,0x00,0xc0,0xc1,0xc2,0x00,0xc5,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x74,0x76,0x79,0x00,
+		0xdb,0xdc,0xdc,0x00,0x9d,0x9e,0x9f,0x00,0x8a,0x8a,0x8b,0x00,0x8c,0x8e,0x8e,0x00,0x92,0x93,0x94,0x00,0x98,0x99,0x9a,0x00,
+		0xbc,0xbc,0xbd,0x00,0xe6,0xe6,0xe6,0x00,0x76,0x78,0x7a,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x6a,0x6c,0x6e,0x00,0xdd,0xdd,0xde,0x00,0xbd,0xbe,0xbe,0x00,0x9b,0x9b,0x9c,0x00,
+		0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xae,0xac,0xa5,0x00,0xa7,0xa4,0x9b,0x00,
+		0xde,0xdc,0xd6,0x00,0xf9,0xeb,0xc4,0x00,0xff,0xc9,0x2f,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x27,0x00,0xfb,0xe0,0x95,0x00,0xf6,0xf3,0xe8,0x00,
+		0xe0,0xd9,0xc8,0x00,0xc5,0xbb,0x98,0x00,0xc2,0xb4,0x8e,0x00,0xc3,0xb5,0x8e,0x00,0xc3,0xb5,0x8c,0x00,0xc4,0xb6,0x8c,0x00,
+		0xc5,0xb6,0x8c,0x00,0xc6,0xb7,0x8b,0x00,0xc7,0xb8,0x8b,0x00,0xca,0xba,0x90,0x00,0xda,0xce,0xb0,0x00,0xf1,0xeb,0xdc,0x00,
+		0xfa,0xf4,0xe3,0x00,0xfc,0xf2,0xd6,0x00,0xeb,0xe2,0xc7,0x00,0xc9,0xb8,0x8b,0x00,0xc9,0xb8,0x8b,0x00,0xf0,0xe7,0xd1,0x00,
+		0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xfd,0xc5,0x26,0x00,0xfa,0xe8,0xb7,0x00,0xe3,0xda,0xc2,0x00,0xc4,0xb7,0x91,0x00,0xc3,0xb7,0x92,0x00,0xc3,0xb7,0x93,0x00,
+		0xc1,0xb7,0x94,0x00,0xc2,0xb7,0x94,0x00,0xc1,0xb7,0x95,0x00,0xc0,0xb6,0x96,0x00,0xc0,0xb6,0x97,0x00,0xbf,0xb5,0x97,0x00,
+		0xbf,0xb5,0x98,0x00,0xbe,0xb3,0x97,0x00,0xba,0xb0,0x93,0x00,0xb5,0xaa,0x8f,0x00,0xae,0xa4,0x87,0x00,0xa0,0x96,0x78,0x00,
+		0x91,0x85,0x66,0x00,0x7f,0x74,0x53,0x00,0x71,0x65,0x42,0x00,0x60,0x55,0x31,0x00,0x55,0x49,0x24,0x00,0x4b,0x3e,0x19,0x00,
+		0x44,0x36,0x10,0x00,0x3e,0x31,0x09,0x00,0x3d,0x2e,0x05,0x00,0x3c,0x2d,0x02,0x00,0x3d,0x2d,0x01,0x00,0x3d,0x2d,0x00,0x00,
+		0x3f,0x2f,0x00,0x00,0x41,0x2f,0x00,0x00,0x42,0x31,0x00,0x00,0x45,0x32,0x00,0x00,0x46,0x33,0x00,0x00,0x47,0x34,0x00,0x00,
+		0x48,0x35,0x00,0x00,0x47,0x35,0x00,0x00,0x47,0x34,0x00,0x00,0x47,0x34,0x00,0x00,0x47,0x34,0x00,0x00,0x46,0x34,0x00,0x00,
+		0x44,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x41,0x2f,0x00,0x00,0x3e,0x2d,0x00,0x00,0x3c,0x2c,0x00,0x00,0x39,0x2a,0x00,0x00,
+		0x36,0x28,0x00,0x00,0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x2e,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x28,0x1d,0x00,0x00,
+		0x25,0x1b,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x11,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,
+		0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x02,0x05,0x00,0x05,0x04,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,
+		0x0a,0x06,0x0b,0x00,0x0c,0x07,0x0e,0x00,0x0f,0x08,0x11,0x00,0x11,0x08,0x14,0x00,0x14,0x0a,0x16,0x00,0x17,0x0b,0x1a,0x00,
+		0x1a,0x0d,0x1d,0x00,0x1e,0x0e,0x21,0x00,0x21,0x10,0x25,0x00,0x25,0x12,0x29,0x00,0x29,0x14,0x2e,0x00,0x2d,0x15,0x33,0x00,
+		0x31,0x17,0x37,0x00,0x36,0x19,0x3c,0x00,0x3a,0x1b,0x40,0x00,0x3d,0x1c,0x44,0x00,0x41,0x1e,0x48,0x00,0x46,0x20,0x4d,0x00,
+		0x49,0x22,0x50,0x00,0x4e,0x25,0x55,0x00,0x51,0x26,0x58,0x00,0x56,0x2a,0x5c,0x00,0x5a,0x2d,0x60,0x00,0x61,0x33,0x67,0x00,
+		0x6a,0x3a,0x6e,0x00,0x72,0x43,0x76,0x00,0x7d,0x4d,0x80,0x00,0x88,0x58,0x8a,0x00,0x92,0x63,0x93,0x00,0x9c,0x6d,0x9b,0x00,
+		0xa7,0x79,0xa5,0x00,0xad,0x7f,0xaa,0x00,0xb3,0x86,0xaf,0x00,0xb9,0x8b,0xb1,0x00,0xbb,0x90,0xb2,0x00,0xfb,0xf3,0xfd,0x00,
+		0xd0,0x53,0xf0,0x00,0xc8,0x2e,0xef,0x00,0xca,0x36,0xf0,0x00,0xc9,0x35,0xf0,0x00,0xc8,0x35,0xef,0x00,0xc9,0x35,0xef,0x00,
+		0xc7,0x35,0xee,0x00,0xc8,0x35,0xef,0x00,0xc7,0x35,0xef,0x00,0xc7,0x35,0xf0,0x00,0xc7,0x35,0xef,0x00,0xc7,0x35,0xef,0x00,
+		0xc6,0x35,0xee,0x00,0xc6,0x36,0xef,0x00,0xc5,0x34,0xee,0x00,0xc2,0x28,0xed,0x00,0xc4,0x2f,0xee,0x00,0xd8,0x7a,0xf5,0x00,
+		0xf6,0xde,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xf7,0xd4,0x00,0xff,0xdf,0x82,0x00,0xff,0xd2,0x4e,0x00,0xff,0xd0,0x4e,0x00,
+		0xff,0xd2,0x55,0x00,0xff,0xc5,0x2e,0x00,0xff,0xa3,0x12,0x00,0xff,0xa1,0x18,0x00,0xff,0x9f,0x12,0x00,0xff,0xb5,0x48,0x00,
+		0xff,0xe1,0xb5,0x00,0xff,0xff,0xff,0x00,0xea,0xfe,0xfc,0x00,0x94,0xed,0xc8,0x00,0x3f,0xdf,0x9b,0x00,0x2e,0xdc,0x93,0x00,
+		0x3b,0xde,0x9a,0x00,0x41,0xdf,0x9e,0x00,0x42,0xe0,0x9f,0x00,0x45,0xe0,0xa0,0x00,0x46,0xe0,0xa2,0x00,0x48,0xe1,0xa3,0x00,
+		0x4b,0xe1,0xa5,0x00,0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,0x51,0xe3,0xa9,0x00,0x52,0xe3,0xaa,0x00,0x55,0xe4,0xab,0x00,
+		0x57,0xe4,0xad,0x00,0x5a,0xe5,0xaf,0x00,0x50,0xe3,0xab,0x00,0x9d,0xef,0xcf,0x00,0xf6,0xf8,0xf7,0x00,0xac,0xbd,0xb5,0x00,
+		0x9d,0xae,0xa7,0x00,0x9d,0xac,0xa6,0x00,0x9d,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,0x9d,0xa7,0xa3,0x00,0x9d,0xa6,0xa2,0x00,
+		0x9c,0xa3,0xa1,0x00,0x9c,0xa2,0x9f,0x00,0x9b,0xa0,0x9e,0x00,0xbf,0xc2,0xc0,0x00,0xdd,0xdd,0xde,0x00,0x60,0x62,0x65,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x67,0x69,0x6c,0x00,0xd3,0xd3,0xd4,0x00,0xea,0xea,0xea,0x00,0xc5,0xc5,0xc5,0x00,0x9a,0x9b,0x9d,0x00,0x8c,0x8d,0x8e,0x00,
+		0x8c,0x8c,0x8e,0x00,0x8b,0x8c,0x8d,0x00,0x8b,0x8c,0x8d,0x00,0x8d,0x8e,0x8f,0x00,0x97,0x97,0x99,0x00,0x96,0x97,0x98,0x00,
+		0x8b,0x8c,0x8d,0x00,0xc2,0xc2,0xc3,0x00,0xc5,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x74,0x77,0x79,0x00,0xdb,0xdc,0xdc,0x00,0x9d,0x9f,0x9f,0x00,
+		0x8f,0x90,0x90,0x00,0x95,0x96,0x97,0x00,0x9a,0x9b,0x9b,0x00,0x9b,0x9b,0x9c,0x00,0xcd,0xcd,0xcd,0x00,0xde,0xdf,0xdf,0x00,
+		0x70,0x72,0x74,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x6d,0x70,0x73,0x00,0xe0,0xe0,0xe1,0x00,0xbe,0xbe,0xbf,0x00,0x9b,0x9b,0x9c,0x00,0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xac,0xaa,0xa2,0x00,0xaf,0xac,0xa4,0x00,0xf0,0xec,0xe3,0x00,0xfe,0xe0,0x8a,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfc,0xe0,0x90,0x00,0xf6,0xf2,0xe9,0x00,0xd6,0xce,0xb9,0x00,0xbf,0xb3,0x90,0x00,0xc1,0xb4,0x8f,0x00,
+		0xc2,0xb4,0x8d,0x00,0xc3,0xb5,0x8d,0x00,0xc4,0xb5,0x8c,0x00,0xc4,0xb6,0x8b,0x00,0xc6,0xb6,0x8b,0x00,0xc7,0xb8,0x8a,0x00,
+		0xc7,0xb8,0x8a,0x00,0xc8,0xb8,0x8a,0x00,0xc8,0xb8,0x8a,0x00,0xcb,0xbc,0x90,0x00,0xde,0xd4,0xb8,0x00,0xe7,0xdf,0xc6,0x00,
+		0xde,0xd4,0xb2,0x00,0xc9,0xb9,0x8b,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe7,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xfe,0xc5,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xeb,0xbd,0x00,
+		0xe5,0xde,0xcc,0x00,0xcc,0xc0,0x9e,0x00,0xcc,0xc0,0xa0,0x00,0xcb,0xc0,0xa0,0x00,0xc9,0xbf,0xa1,0x00,0xc9,0xc0,0xa2,0x00,
+		0xc8,0xbe,0xa2,0x00,0xc7,0xbf,0xa4,0x00,0xc7,0xbe,0xa4,0x00,0xc7,0xbd,0xa4,0x00,0xc6,0xbe,0xa4,0x00,0xc5,0xbc,0xa3,0x00,
+		0xbb,0xb1,0x95,0x00,0xb1,0xa6,0x88,0x00,0xa4,0x9a,0x7b,0x00,0x98,0x8c,0x6c,0x00,0x8b,0x80,0x5e,0x00,0x7c,0x70,0x4f,0x00,
+		0x6e,0x62,0x40,0x00,0x60,0x55,0x31,0x00,0x55,0x48,0x23,0x00,0x4b,0x3e,0x19,0x00,0x43,0x36,0x10,0x00,0x3e,0x31,0x09,0x00,
+		0x3c,0x2d,0x05,0x00,0x3b,0x2d,0x02,0x00,0x3e,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,0x40,0x30,0x00,0x00,0x42,0x30,0x00,0x00,
+		0x43,0x32,0x00,0x00,0x45,0x33,0x00,0x00,0x46,0x34,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x47,0x35,0x00,0x00,0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x43,0x31,0x00,0x00,
+		0x41,0x30,0x00,0x00,0x40,0x30,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,0x38,0x29,0x00,0x00,0x34,0x26,0x00,0x00,
+		0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2c,0x21,0x00,0x00,0x28,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,
+		0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x1a,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,
+		0x05,0x02,0x06,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x06,0x0e,0x00,
+		0x0f,0x07,0x11,0x00,0x11,0x08,0x14,0x00,0x14,0x09,0x15,0x00,0x16,0x0b,0x19,0x00,0x1a,0x0c,0x1e,0x00,0x1e,0x0e,0x21,0x00,
+		0x21,0x10,0x26,0x00,0x25,0x11,0x2a,0x00,0x29,0x13,0x2e,0x00,0x2d,0x14,0x33,0x00,0x32,0x16,0x38,0x00,0x36,0x18,0x3c,0x00,
+		0x3a,0x1a,0x41,0x00,0x3d,0x1b,0x44,0x00,0x41,0x1d,0x49,0x00,0x45,0x1f,0x4d,0x00,0x49,0x21,0x51,0x00,0x4d,0x23,0x55,0x00,
+		0x51,0x25,0x59,0x00,0x55,0x28,0x5d,0x00,0x5b,0x2c,0x61,0x00,0x61,0x32,0x68,0x00,0x68,0x39,0x6e,0x00,0x72,0x41,0x77,0x00,
+		0x7d,0x4b,0x82,0x00,0x87,0x56,0x8b,0x00,0x92,0x61,0x94,0x00,0x9b,0x6c,0x9d,0x00,0xa6,0x75,0xa7,0x00,0xac,0x7e,0xab,0x00,
+		0xb2,0x84,0xb0,0x00,0xb8,0x8a,0xb3,0x00,0xba,0x8e,0xb4,0x00,0xfa,0xf2,0xfc,0x00,0xcf,0x53,0xf1,0x00,0xc4,0x2d,0xec,0x00,
+		0xc7,0x35,0xee,0x00,0xc6,0x35,0xee,0x00,0xc7,0x35,0xef,0x00,0xc7,0x35,0xef,0x00,0xc7,0x35,0xee,0x00,0xc7,0x35,0xef,0x00,
+		0xc6,0x35,0xef,0x00,0xc6,0x35,0xef,0x00,0xc6,0x35,0xef,0x00,0xc5,0x35,0xee,0x00,0xc5,0x34,0xef,0x00,0xc5,0x35,0xee,0x00,
+		0xc5,0x35,0xee,0x00,0xc5,0x35,0xee,0x00,0xc4,0x33,0xed,0x00,0xc0,0x27,0xec,0x00,0xc6,0x3e,0xee,0x00,0xe1,0x9a,0xf7,0x00,
+		0xfc,0xf5,0xff,0x00,0xff,0xff,0xfa,0x00,0xff,0xef,0xba,0x00,0xff,0xd7,0x65,0x00,0xff,0xcf,0x48,0x00,0xff,0xc3,0x24,0x00,
+		0xff,0x9c,0x00,0x00,0xff,0xa8,0x2a,0x00,0xff,0xd4,0x97,0x00,0xff,0xf9,0xf4,0x00,0xfb,0xff,0xff,0x00,0xad,0xf1,0xd5,0x00,
+		0x4b,0xe0,0xa1,0x00,0x28,0xda,0x8f,0x00,0x33,0xdd,0x95,0x00,0x3a,0xde,0x99,0x00,0x3c,0xde,0x9a,0x00,0x3e,0xdf,0x9c,0x00,
+		0x40,0xdf,0x9d,0x00,0x43,0xe0,0x9f,0x00,0x44,0xe0,0xa0,0x00,0x46,0xe1,0xa2,0x00,0x49,0xe1,0xa3,0x00,0x4b,0xe1,0xa4,0x00,
+		0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,0x50,0xe3,0xa8,0x00,0x53,0xe3,0xaa,0x00,0x54,0xe3,0xab,0x00,0x58,0xe4,0xad,0x00,
+		0x4f,0xe3,0xa9,0x00,0x9c,0xef,0xcf,0x00,0xf6,0xf8,0xf7,0x00,0xac,0xbd,0xb5,0x00,0x9c,0xae,0xa7,0x00,0x9d,0xac,0xa6,0x00,
+		0x9d,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,0x9d,0xa7,0xa3,0x00,0x9d,0xa6,0xa2,0x00,0x9c,0xa3,0xa1,0x00,0x9c,0xa2,0x9f,0x00,
+		0x9b,0xa0,0x9e,0x00,0xad,0xb1,0xb0,0x00,0xea,0xeb,0xeb,0x00,0x90,0x92,0x94,0x00,0x48,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x56,0x59,0x5c,0x00,
+		0xa1,0xa2,0xa4,0x00,0xe6,0xe6,0xe6,0x00,0xe3,0xe3,0xe4,0x00,0xc5,0xc5,0xc6,0x00,0x9c,0x9c,0x9d,0x00,0x8b,0x8c,0x8d,0x00,
+		0x8b,0x8b,0x8c,0x00,0x8b,0x8c,0x8d,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,0xc2,0xc2,0xc3,0x00,
+		0xc5,0xc6,0xc7,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x78,0x7b,0x7d,0x00,0xdf,0xe0,0xe0,0x00,0xa5,0xa6,0xa6,0x00,0x99,0x9a,0x9a,0x00,0x9b,0x9b,0x9c,0x00,
+		0xa1,0xa1,0xa1,0x00,0xc2,0xc3,0xc3,0x00,0xeb,0xeb,0xeb,0x00,0xb2,0xb2,0xb4,0x00,0x63,0x65,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x83,0x84,0x86,0x00,0xe9,0xe9,0xe9,0x00,
+		0xb8,0xb8,0xb8,0x00,0x9b,0x9b,0x9c,0x00,0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,
+		0xab,0xa8,0xa1,0x00,0xb8,0xb5,0xad,0x00,0xf5,0xef,0xdf,0x00,0xff,0xd4,0x5c,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xd2,0x51,0x00,0xf9,0xf4,0xe4,0x00,
+		0xda,0xd4,0xc3,0x00,0xbe,0xb2,0x90,0x00,0xbf,0xb2,0x8f,0x00,0xc1,0xb3,0x8e,0x00,0xc2,0xb4,0x8d,0x00,0xc3,0xb5,0x8c,0x00,
+		0xc4,0xb5,0x8b,0x00,0xc5,0xb6,0x8b,0x00,0xc6,0xb7,0x8b,0x00,0xc7,0xb7,0x8a,0x00,0xc7,0xb7,0x8a,0x00,0xc8,0xb8,0x8a,0x00,
+		0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb8,0x8a,0x00,0xf0,0xe8,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xdd,0x87,0x00,0xf6,0xef,0xd9,0x00,0xf4,0xec,0xd6,0x00,
+		0xf5,0xed,0xd8,0x00,0xf4,0xec,0xd7,0x00,0xf4,0xec,0xd7,0x00,0xf4,0xec,0xd7,0x00,0xf4,0xec,0xd8,0x00,0xf5,0xed,0xd9,0x00,
+		0xf4,0xec,0xd8,0x00,0xf4,0xec,0xd8,0x00,0xf3,0xeb,0xd5,0x00,0xee,0xe7,0xd6,0x00,0xbf,0xb6,0x9d,0x00,0xaa,0x9f,0x7f,0x00,
+		0xa1,0x96,0x76,0x00,0x97,0x8c,0x6b,0x00,0x8b,0x7f,0x5e,0x00,0x7d,0x71,0x4f,0x00,0x6d,0x61,0x3f,0x00,0x60,0x53,0x31,0x00,
+		0x54,0x47,0x22,0x00,0x4a,0x3d,0x18,0x00,0x43,0x35,0x0f,0x00,0x3f,0x30,0x09,0x00,0x3d,0x2d,0x05,0x00,0x3c,0x2d,0x02,0x00,
+		0x3d,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,0x40,0x2f,0x00,0x00,0x42,0x30,0x00,0x00,0x44,0x33,0x00,0x00,0x45,0x33,0x00,0x00,
+		0x47,0x34,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x48,0x36,0x00,0x00,0x48,0x36,0x00,0x00,
+		0x48,0x36,0x00,0x00,0x47,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x43,0x31,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x3e,0x2e,0x00,0x00,0x3a,0x2b,0x00,0x00,0x38,0x2a,0x00,0x00,0x34,0x26,0x00,0x00,0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,
+		0x2b,0x20,0x00,0x00,0x29,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x22,0x1a,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x19,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x02,0x05,0x00,0x05,0x03,0x06,0x00,
+		0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0f,0x07,0x11,0x00,0x11,0x08,0x14,0x00,
+		0x14,0x09,0x16,0x00,0x16,0x0b,0x19,0x00,0x19,0x0c,0x1d,0x00,0x1d,0x0e,0x21,0x00,0x21,0x0f,0x26,0x00,0x25,0x11,0x2a,0x00,
+		0x29,0x13,0x2e,0x00,0x2d,0x14,0x33,0x00,0x31,0x16,0x37,0x00,0x36,0x18,0x3c,0x00,0x3a,0x1a,0x42,0x00,0x3e,0x1b,0x45,0x00,
+		0x41,0x1c,0x48,0x00,0x45,0x1e,0x4d,0x00,0x49,0x20,0x52,0x00,0x4d,0x22,0x56,0x00,0x50,0x24,0x59,0x00,0x55,0x27,0x5e,0x00,
+		0x59,0x2a,0x61,0x00,0x60,0x30,0x68,0x00,0x68,0x37,0x70,0x00,0x71,0x40,0x78,0x00,0x7b,0x4a,0x80,0x00,0x86,0x54,0x8b,0x00,
+		0x90,0x5f,0x94,0x00,0x9a,0x6a,0x9f,0x00,0xa5,0x73,0xa8,0x00,0xac,0x7c,0xae,0x00,0xb2,0x82,0xb2,0x00,0xb6,0x88,0xb5,0x00,
+		0xb8,0x8b,0xb5,0x00,0xfb,0xf3,0xfd,0x00,0xcd,0x52,0xef,0x00,0xc4,0x2d,0xed,0x00,0xc5,0x35,0xed,0x00,0xc6,0x35,0xef,0x00,
+		0xc5,0x35,0xed,0x00,0xc6,0x35,0xef,0x00,0xc5,0x35,0xed,0x00,0xc6,0x35,0xef,0x00,0xc4,0x35,0xee,0x00,0xc5,0x35,0xee,0x00,
+		0xc5,0x35,0xef,0x00,0xc5,0x35,0xee,0x00,0xc4,0x35,0xee,0x00,0xc4,0x35,0xee,0x00,0xc4,0x35,0xee,0x00,0xc3,0x34,0xee,0x00,
+		0xc3,0x34,0xed,0x00,0xc3,0x35,0xed,0x00,0xc1,0x2e,0xec,0x00,0xbe,0x26,0xec,0x00,0xca,0x51,0xf0,0x00,0xea,0xb9,0xfb,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xef,0x00,0xff,0xe6,0x9e,0x00,0xff,0xc8,0x3a,0x00,0xff,0xc5,0x68,0x00,0xff,0xf2,0xe3,0x00,
+		0xff,0xff,0xff,0x00,0xc6,0xf7,0xe5,0x00,0x5e,0xe3,0xab,0x00,0x26,0xdb,0x8d,0x00,0x27,0xdb,0x8e,0x00,0x33,0xdc,0x94,0x00,
+		0x36,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x39,0xde,0x99,0x00,0x3c,0xdf,0x9b,0x00,0x3e,0xdf,0x9c,0x00,0x40,0xe0,0x9e,0x00,
+		0x42,0xe0,0x9f,0x00,0x45,0xdf,0xa0,0x00,0x47,0xe1,0xa2,0x00,0x49,0xe1,0xa3,0x00,0x4a,0xe1,0xa5,0x00,0x4d,0xe2,0xa7,0x00,
+		0x4f,0xe2,0xa7,0x00,0x51,0xe3,0xa9,0x00,0x53,0xe3,0xa9,0x00,0x54,0xe3,0xab,0x00,0x4d,0xe2,0xa8,0x00,0x9a,0xef,0xce,0x00,
+		0xf6,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9c,0xae,0xa6,0x00,0x9c,0xac,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,
+		0x9c,0xa7,0xa3,0x00,0x9c,0xa6,0xa2,0x00,0x9c,0xa3,0xa1,0x00,0x9b,0xa1,0x9f,0x00,0x9b,0xa0,0x9e,0x00,0x9a,0x9e,0x9d,0x00,
+		0xd5,0xd6,0xd6,0x00,0xd9,0xda,0xda,0x00,0x57,0x59,0x5c,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x65,0x67,0x6a,0x00,
+		0xa9,0xaa,0xac,0x00,0xdf,0xdf,0xe0,0x00,0xe9,0xe9,0xea,0x00,0xc7,0xc7,0xc8,0x00,0x9f,0xa0,0xa1,0x00,0x8a,0x8b,0x8c,0x00,
+		0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,0xc2,0xc2,0xc3,0x00,0xc5,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4a,0x4e,0x00,0x6f,0x71,0x74,0x00,
+		0xd8,0xd9,0xda,0x00,0xe0,0xe0,0xe1,0x00,0xdb,0xdb,0xdc,0x00,0xdb,0xdb,0xdb,0x00,0xe4,0xe4,0xe4,0x00,0xea,0xeb,0xeb,0x00,
+		0xb8,0xb9,0xba,0x00,0x68,0x69,0x6d,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x99,0x9b,0x9c,0x00,0xe8,0xe8,0xe9,0x00,0xa7,0xa8,0xa8,0x00,0x9b,0x9c,0x9c,0x00,
+		0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xac,0xa9,0xa1,0x00,0xbc,0xb9,0xb2,0x00,
+		0xf7,0xf1,0xdf,0x00,0xff,0xcf,0x4a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc8,0x28,0x00,0xfc,0xe6,0xa9,0x00,0xf0,0xeb,0xe1,0x00,0xc3,0xb8,0x9a,0x00,0xbe,0xb2,0x90,0x00,
+		0xbf,0xb3,0x8f,0x00,0xc1,0xb3,0x8e,0x00,0xc3,0xb5,0x8d,0x00,0xc3,0xb5,0x8c,0x00,0xc4,0xb5,0x8b,0x00,0xc6,0xb6,0x8a,0x00,
+		0xc6,0xb7,0x8a,0x00,0xc7,0xb7,0x8a,0x00,0xc7,0xb8,0x8a,0x00,0xc8,0xb8,0x89,0x00,0xc8,0xb8,0x89,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb8,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe8,0xd0,0x00,
+		0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xfe,0xc6,0x26,0x00,0xff,0xc9,0x2d,0x00,0xff,0xd5,0x5f,0x00,0xfe,0xd7,0x67,0x00,0xfe,0xd6,0x66,0x00,0xfd,0xd5,0x65,0x00,
+		0xfd,0xd5,0x65,0x00,0xfe,0xd6,0x66,0x00,0xfd,0xd5,0x65,0x00,0xfd,0xd5,0x65,0x00,0xfd,0xd4,0x63,0x00,0xfd,0xd3,0x5c,0x00,
+		0xfd,0xd5,0x63,0x00,0xf4,0xeb,0xd2,0x00,0xc0,0xb8,0x9f,0x00,0xa7,0x9c,0x7c,0x00,0x9f,0x95,0x74,0x00,0x96,0x8b,0x6b,0x00,
+		0x8a,0x7f,0x5e,0x00,0x7c,0x70,0x50,0x00,0x6e,0x62,0x40,0x00,0x61,0x54,0x31,0x00,0x54,0x47,0x23,0x00,0x4a,0x3d,0x18,0x00,
+		0x43,0x35,0x0f,0x00,0x3e,0x30,0x09,0x00,0x3d,0x2e,0x05,0x00,0x3c,0x2e,0x02,0x00,0x3d,0x2d,0x01,0x00,0x3f,0x2e,0x00,0x00,
+		0x41,0x30,0x00,0x00,0x43,0x32,0x00,0x00,0x45,0x33,0x00,0x00,0x45,0x33,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x36,0x00,0x00,
+		0x48,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x48,0x36,0x00,0x00,0x48,0x35,0x00,0x00,0x46,0x34,0x00,0x00,
+		0x46,0x33,0x00,0x00,0x44,0x32,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,
+		0x38,0x29,0x00,0x00,0x35,0x27,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2c,0x20,0x00,0x00,0x29,0x1f,0x00,0x00,
+		0x26,0x1d,0x00,0x00,0x23,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1d,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x10,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,
+		0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x04,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,
+		0x0a,0x05,0x0b,0x00,0x0c,0x07,0x0e,0x00,0x0e,0x07,0x11,0x00,0x11,0x08,0x14,0x00,0x14,0x09,0x17,0x00,0x16,0x0b,0x19,0x00,
+		0x1a,0x0c,0x1d,0x00,0x1d,0x0e,0x21,0x00,0x21,0x0f,0x26,0x00,0x25,0x11,0x2a,0x00,0x29,0x12,0x2f,0x00,0x2c,0x14,0x32,0x00,
+		0x31,0x15,0x37,0x00,0x35,0x17,0x3d,0x00,0x38,0x19,0x41,0x00,0x3d,0x1a,0x44,0x00,0x40,0x1c,0x49,0x00,0x43,0x1d,0x4d,0x00,
+		0x48,0x1f,0x52,0x00,0x4d,0x21,0x56,0x00,0x4f,0x23,0x59,0x00,0x54,0x26,0x5e,0x00,0x59,0x29,0x62,0x00,0x60,0x2f,0x68,0x00,
+		0x68,0x36,0x71,0x00,0x71,0x3e,0x79,0x00,0x7b,0x48,0x82,0x00,0x84,0x52,0x8b,0x00,0x91,0x5e,0x96,0x00,0x9b,0x68,0xa1,0x00,
+		0xa3,0x71,0xa7,0x00,0xab,0x7a,0xae,0x00,0xb1,0x81,0xb3,0x00,0xb4,0x85,0xb5,0x00,0xb8,0x8a,0xb7,0x00,0xfa,0xf2,0xfc,0x00,
+		0xcd,0x53,0xf0,0x00,0xc4,0x2d,0xee,0x00,0xc5,0x35,0xee,0x00,0xc5,0x35,0xee,0x00,0xc4,0x35,0xed,0x00,0xc5,0x35,0xee,0x00,
+		0xc5,0x35,0xee,0x00,0xc4,0x34,0xee,0x00,0xc4,0x35,0xee,0x00,0xc4,0x34,0xed,0x00,0xc3,0x34,0xed,0x00,0xc3,0x34,0xed,0x00,
+		0xc3,0x34,0xed,0x00,0xc3,0x35,0xed,0x00,0xc2,0x34,0xed,0x00,0xc2,0x34,0xed,0x00,0xc2,0x34,0xed,0x00,0xc1,0x34,0xec,0x00,
+		0xc1,0x34,0xec,0x00,0xc1,0x34,0xec,0x00,0xbd,0x2b,0xec,0x00,0xbd,0x2b,0xeb,0x00,0xd2,0x6f,0xf2,0x00,0xf2,0xd3,0xff,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xf9,0xe5,0x00,0xff,0xff,0xff,0x00,0xdf,0xfc,0xf3,0x00,0x7a,0xe9,0xba,0x00,0x2e,0xdb,0x91,0x00,
+		0x25,0xda,0x8d,0x00,0x30,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x33,0xdc,0x94,0x00,0x35,0xdd,0x96,0x00,
+		0x38,0xdd,0x97,0x00,0x3a,0xde,0x99,0x00,0x3c,0xde,0x9a,0x00,0x3e,0xdf,0x9c,0x00,0x40,0xdf,0x9d,0x00,0x43,0xe0,0x9f,0x00,
+		0x45,0xe0,0xa0,0x00,0x47,0xe1,0xa2,0x00,0x49,0xe1,0xa3,0x00,0x4b,0xe1,0xa5,0x00,0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,
+		0x51,0xe3,0xa8,0x00,0x53,0xe3,0xaa,0x00,0x4a,0xe2,0xa6,0x00,0x99,0xef,0xcd,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,
+		0x9b,0xae,0xa7,0x00,0x9c,0xac,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,0x9c,0xa7,0xa3,0x00,0x9c,0xa6,0xa2,0x00,
+		0x9c,0xa4,0xa1,0x00,0x9b,0xa2,0xa0,0x00,0x9b,0xa0,0x9e,0x00,0x9a,0x9e,0x9d,0x00,0xab,0xae,0xad,0x00,0xe9,0xea,0xea,0x00,
+		0xb7,0xb8,0xb9,0x00,0x4c,0x4f,0x52,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x62,0x63,0x67,0x00,
+		0xa0,0xa1,0xa3,0x00,0xdf,0xe0,0xe0,0x00,0xe6,0xe7,0xe7,0x00,0xb5,0xb5,0xb6,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8b,0x8c,0x00,
+		0x8a,0x8b,0x8c,0x00,0xc2,0xc2,0xc3,0x00,0xc5,0xc6,0xc7,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x4a,0x4d,0x50,0x00,0x52,0x54,0x57,0x00,0x5d,0x5e,0x62,0x00,0x88,0x89,0x8c,0x00,0xac,0xac,0xae,0x00,
+		0xab,0xac,0xae,0x00,0xab,0xac,0xae,0x00,0xa9,0xaa,0xac,0x00,0x8a,0x8b,0x8e,0x00,0x63,0x66,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x69,0x6b,0x6e,0x00,
+		0xd3,0xd3,0xd4,0x00,0xdd,0xdd,0xdd,0x00,0xa0,0xa1,0xa1,0x00,0x9c,0x9c,0x9c,0x00,0xc0,0xbf,0xbf,0x00,0xf6,0xeb,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xac,0xaa,0xa1,0x00,0xc3,0xc0,0xb8,0x00,0xf8,0xf1,0xdd,0x00,0xff,0xce,0x3f,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xca,0x33,0x00,
+		0xfa,0xee,0xcc,0x00,0xdd,0xd7,0xc8,0x00,0xbd,0xb2,0x91,0x00,0xbe,0xb2,0x90,0x00,0xc0,0xb3,0x8f,0x00,0xc1,0xb3,0x8e,0x00,
+		0xc2,0xb4,0x8d,0x00,0xc3,0xb5,0x8c,0x00,0xc5,0xb6,0x8b,0x00,0xc6,0xb7,0x8a,0x00,0xc7,0xb7,0x8a,0x00,0xc7,0xb8,0x8a,0x00,
+		0xc8,0xb8,0x8a,0x00,0xc8,0xb8,0x89,0x00,0xc8,0xb8,0x89,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe7,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xfe,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,
+		0xfe,0xc6,0x26,0x00,0xfd,0xc4,0x26,0x00,0xff,0xc7,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfd,0xc5,0x26,0x00,
+		0xfe,0xc5,0x24,0x00,0xfd,0xc2,0x1c,0x00,0xfd,0xbf,0x10,0x00,0xfd,0xbe,0x07,0x00,0xfd,0xc7,0x2f,0x00,0xf4,0xeb,0xd0,0x00,
+		0xbf,0xb5,0x9c,0x00,0xa8,0x9d,0x7d,0x00,0x9f,0x94,0x75,0x00,0x97,0x8b,0x6b,0x00,0x89,0x7d,0x5e,0x00,0x7c,0x70,0x50,0x00,
+		0x6d,0x60,0x40,0x00,0x60,0x54,0x31,0x00,0x53,0x47,0x23,0x00,0x4a,0x3d,0x18,0x00,0x43,0x35,0x0f,0x00,0x3f,0x30,0x09,0x00,
+		0x3d,0x2e,0x05,0x00,0x3d,0x2e,0x02,0x00,0x3d,0x2e,0x01,0x00,0x3e,0x2e,0x00,0x00,0x41,0x30,0x00,0x00,0x43,0x32,0x00,0x00,
+		0x44,0x33,0x00,0x00,0x46,0x33,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x49,0x36,0x00,0x00,
+		0x49,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x45,0x33,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x42,0x31,0x00,0x00,0x41,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3c,0x2d,0x00,0x00,0x38,0x29,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x32,0x25,0x00,0x00,0x2e,0x22,0x00,0x00,0x2d,0x21,0x00,0x00,0x29,0x1f,0x00,0x00,0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,
+		0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,
+		0x05,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,
+		0x0e,0x07,0x11,0x00,0x11,0x08,0x14,0x00,0x14,0x09,0x16,0x00,0x16,0x0a,0x19,0x00,0x1a,0x0c,0x1d,0x00,0x1d,0x0d,0x21,0x00,
+		0x21,0x0f,0x26,0x00,0x25,0x10,0x2a,0x00,0x29,0x12,0x2f,0x00,0x2c,0x14,0x33,0x00,0x30,0x15,0x37,0x00,0x34,0x17,0x3c,0x00,
+		0x38,0x19,0x41,0x00,0x3d,0x1a,0x44,0x00,0x40,0x1b,0x4a,0x00,0x44,0x1d,0x4e,0x00,0x48,0x1e,0x51,0x00,0x4c,0x21,0x57,0x00,
+		0x51,0x22,0x5b,0x00,0x54,0x25,0x5f,0x00,0x58,0x28,0x62,0x00,0x5f,0x2e,0x69,0x00,0x67,0x35,0x71,0x00,0x70,0x3d,0x7a,0x00,
+		0x7a,0x46,0x83,0x00,0x84,0x51,0x8c,0x00,0x90,0x5c,0x98,0x00,0x99,0x65,0xa0,0x00,0xa2,0x70,0xa8,0x00,0xaa,0x79,0xaf,0x00,
+		0xb0,0x7f,0xb4,0x00,0xb5,0x85,0xb8,0x00,0xb7,0x88,0xb9,0x00,0xfb,0xf3,0xfd,0x00,0xcc,0x53,0xf0,0x00,0xc2,0x2d,0xec,0x00,
+		0xc5,0x35,0xee,0x00,0xc4,0x35,0xed,0x00,0xc4,0x34,0xed,0x00,0xc4,0x34,0xee,0x00,0xc4,0x34,0xee,0x00,0xc3,0x34,0xed,0x00,
+		0xc3,0x34,0xed,0x00,0xc3,0x34,0xed,0x00,0xc1,0x34,0xeb,0x00,0xc2,0x34,0xed,0x00,0xc2,0x34,0xed,0x00,0xc1,0x34,0xed,0x00,
+		0xc1,0x34,0xed,0x00,0xc1,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,
+		0xbf,0x35,0xec,0x00,0xbd,0x31,0xeb,0x00,0xbc,0x25,0xec,0x00,0xbc,0x32,0xea,0x00,0xce,0x93,0xe9,0x00,0xfe,0xfa,0xff,0x00,
+		0xcc,0xf7,0xe2,0x00,0x35,0xd9,0x8f,0x00,0x21,0xda,0x8b,0x00,0x2e,0xdc,0x92,0x00,0x32,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,
+		0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x31,0xdd,0x93,0x00,0x33,0xdc,0x95,0x00,0x35,0xdd,0x96,0x00,0x37,0xde,0x98,0x00,
+		0x39,0xde,0x99,0x00,0x3b,0xde,0x9a,0x00,0x3e,0xdf,0x9c,0x00,0x40,0xdf,0x9d,0x00,0x42,0xe0,0x9f,0x00,0x45,0xe0,0xa0,0x00,
+		0x47,0xe0,0xa2,0x00,0x48,0xe1,0xa3,0x00,0x4b,0xe1,0xa4,0x00,0x4d,0xe2,0xa6,0x00,0x4e,0xe2,0xa7,0x00,0x51,0xe3,0xa9,0x00,
+		0x47,0xe1,0xa5,0x00,0x97,0xee,0xcc,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xae,0xa7,0x00,0x9c,0xac,0xa6,0x00,
+		0x9c,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,0x9c,0xa7,0xa3,0x00,0x9c,0xa6,0xa2,0x00,0x9c,0xa4,0xa1,0x00,0x9b,0xa2,0x9f,0x00,
+		0x9b,0xa0,0x9e,0x00,0x9a,0x9f,0x9d,0x00,0x99,0x9d,0x9c,0x00,0xb8,0xba,0xb9,0x00,0xea,0xeb,0xeb,0x00,0xbd,0xbe,0xbf,0x00,
+		0x5f,0x61,0x64,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x58,0x5a,0x5d,0x00,
+		0xaa,0xab,0xac,0x00,0xe9,0xe9,0xe9,0x00,0xb7,0xb8,0xb8,0x00,0x8a,0x8b,0x8c,0x00,0x8a,0x8a,0x8b,0x00,0xc1,0xc2,0xc3,0x00,
+		0xc5,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x48,0x4b,0x4e,0x00,0x4d,0x50,0x53,0x00,0x57,0x5a,0x5c,0x00,
+		0x60,0x62,0x65,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x96,0x97,0x9a,0x00,0xeb,0xeb,0xeb,0x00,0xb8,0xb9,0xb9,0x00,
+		0x9b,0x9c,0x9c,0x00,0x9c,0x9c,0x9c,0x00,0xc1,0xc0,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,
+		0xac,0xaa,0xa1,0x00,0xc4,0xc2,0xbb,0x00,0xf9,0xf0,0xd4,0x00,0xff,0xca,0x34,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xce,0x42,0x00,0xf8,0xef,0xd4,0x00,0xd4,0xce,0xbb,0x00,
+		0xbd,0xb2,0x91,0x00,0xbf,0xb2,0x90,0x00,0xc0,0xb3,0x8f,0x00,0xc2,0xb4,0x8d,0x00,0xc3,0xb5,0x8c,0x00,0xc4,0xb5,0x8c,0x00,
+		0xc5,0xb6,0x8b,0x00,0xc6,0xb7,0x8a,0x00,0xc6,0xb7,0x8a,0x00,0xc7,0xb7,0x8a,0x00,0xc8,0xb8,0x89,0x00,0xc8,0xb8,0x89,0x00,
+		0xc9,0xb8,0x89,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb9,0x8a,0x00,
+		0xc9,0xb8,0x8a,0x00,0xf0,0xe7,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xfe,0xc6,0x26,0x00,0xfd,0xc4,0x26,0x00,0xff,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,
+		0xfd,0xc5,0x26,0x00,0xff,0xc7,0x26,0x00,0xfd,0xc4,0x24,0x00,0xfe,0xc4,0x1e,0x00,0xfd,0xc0,0x13,0x00,0xfe,0xbe,0x08,0x00,
+		0xfe,0xbd,0x03,0x00,0xfd,0xbb,0x01,0x00,0xfc,0xc8,0x31,0x00,0xf3,0xea,0xd0,0x00,0xbe,0xb6,0x9d,0x00,0xa6,0x9c,0x7c,0x00,
+		0xa1,0x96,0x76,0x00,0x94,0x89,0x6a,0x00,0x89,0x7e,0x5e,0x00,0x7d,0x71,0x50,0x00,0x6e,0x61,0x40,0x00,0x5f,0x54,0x31,0x00,
+		0x53,0x47,0x23,0x00,0x4a,0x3d,0x18,0x00,0x43,0x35,0x0f,0x00,0x3f,0x30,0x09,0x00,0x3d,0x2e,0x05,0x00,0x3d,0x2e,0x02,0x00,
+		0x3d,0x2e,0x01,0x00,0x3f,0x2f,0x00,0x00,0x41,0x31,0x00,0x00,0x43,0x32,0x00,0x00,0x44,0x33,0x00,0x00,0x46,0x34,0x00,0x00,
+		0x48,0x34,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x47,0x35,0x00,0x00,0x47,0x34,0x00,0x00,0x46,0x33,0x00,0x00,0x44,0x32,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,0x38,0x29,0x00,0x00,0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x2e,0x22,0x00,0x00,
+		0x2d,0x22,0x00,0x00,0x29,0x1f,0x00,0x00,0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x1a,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x02,0x05,0x00,0x05,0x03,0x06,0x00,
+		0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0e,0x07,0x11,0x00,0x11,0x08,0x14,0x00,
+		0x13,0x09,0x16,0x00,0x16,0x0a,0x19,0x00,0x19,0x0c,0x1d,0x00,0x1d,0x0d,0x21,0x00,0x20,0x0f,0x25,0x00,0x24,0x10,0x2a,0x00,
+		0x28,0x12,0x2e,0x00,0x2c,0x13,0x33,0x00,0x30,0x15,0x38,0x00,0x35,0x17,0x3d,0x00,0x38,0x18,0x41,0x00,0x3d,0x19,0x46,0x00,
+		0x40,0x1b,0x4a,0x00,0x44,0x1c,0x4d,0x00,0x48,0x1e,0x52,0x00,0x4c,0x20,0x57,0x00,0x50,0x22,0x5b,0x00,0x54,0x25,0x5f,0x00,
+		0x57,0x27,0x63,0x00,0x5f,0x2d,0x6a,0x00,0x67,0x34,0x72,0x00,0x71,0x3c,0x7b,0x00,0x7a,0x46,0x83,0x00,0x85,0x50,0x8e,0x00,
+		0x8f,0x5b,0x99,0x00,0x99,0x64,0xa1,0x00,0xa3,0x70,0xaa,0x00,0xab,0x77,0xb1,0x00,0xaf,0x7e,0xb5,0x00,0xb4,0x83,0xba,0x00,
+		0xb6,0x87,0xba,0x00,0xfa,0xf2,0xfc,0x00,0xcb,0x52,0xee,0x00,0xc0,0x2c,0xec,0x00,0xc1,0x36,0xeb,0x00,0xc2,0x34,0xec,0x00,
+		0xc2,0x34,0xec,0x00,0xc2,0x34,0xed,0x00,0xc2,0x34,0xed,0x00,0xc1,0x34,0xed,0x00,0xc0,0x34,0xec,0x00,0xc1,0x34,0xed,0x00,
+		0xc1,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,0xbf,0x33,0xec,0x00,0xbf,0x34,0xec,0x00,
+		0xbf,0x34,0xec,0x00,0xbe,0x34,0xec,0x00,0xbe,0x34,0xeb,0x00,0xbe,0x34,0xeb,0x00,0xc0,0x34,0xed,0x00,0xbf,0x32,0xec,0x00,
+		0xb1,0x33,0xe0,0x00,0x9d,0x2f,0xd2,0x00,0xab,0x45,0xdb,0x00,0xfd,0xe4,0xff,0x00,0xbf,0xfc,0xe3,0x00,0x30,0xdb,0x97,0x00,
+		0x2b,0xd6,0x88,0x00,0x2e,0xda,0x8d,0x00,0x31,0xdd,0x93,0x00,0x31,0xdc,0x94,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,
+		0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x32,0xdc,0x94,0x00,0x35,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x39,0xde,0x99,0x00,
+		0x3c,0xde,0x9a,0x00,0x3e,0xdf,0x9c,0x00,0x40,0xdf,0x9d,0x00,0x42,0xe0,0x9e,0x00,0x44,0xdf,0xa0,0x00,0x46,0xe0,0xa1,0x00,
+		0x49,0xe1,0xa2,0x00,0x4b,0xe1,0xa4,0x00,0x4d,0xe2,0xa6,0x00,0x4f,0xe2,0xa7,0x00,0x45,0xe1,0xa4,0x00,0x97,0xee,0xcb,0x00,
+		0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xae,0xa6,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,
+		0x9c,0xa8,0xa3,0x00,0x9c,0xa5,0xa2,0x00,0x9c,0xa4,0xa1,0x00,0x9b,0xa2,0xa0,0x00,0x9a,0xa0,0x9e,0x00,0x9a,0x9e,0x9d,0x00,
+		0x99,0x9c,0x9b,0x00,0x98,0x9b,0x9b,0x00,0xb6,0xb7,0xb7,0x00,0xe6,0xe7,0xe7,0x00,0xdd,0xde,0xde,0x00,0x94,0x96,0x97,0x00,
+		0x50,0x52,0x55,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x48,0x4b,0x4e,0x00,0xa3,0xa4,0xa6,0x00,
+		0xe9,0xe9,0xe9,0x00,0xb4,0xb4,0xb5,0x00,0x89,0x8b,0x8b,0x00,0xc1,0xc1,0xc2,0x00,0xc5,0xc6,0xc7,0x00,0x47,0x49,0x4d,0x00,
+		0x49,0x4b,0x4f,0x00,0x50,0x53,0x55,0x00,0x5b,0x5d,0x61,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x63,0x65,0x68,0x00,
+		0x96,0x97,0x9a,0x00,0xe3,0xe3,0xe4,0x00,0xda,0xda,0xda,0x00,0x9e,0x9f,0x9f,0x00,0x9b,0x9c,0x9c,0x00,0x9c,0x9d,0x9d,0x00,
+		0xc1,0xc0,0xbf,0x00,0xf6,0xeb,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xef,0xea,0xda,0x00,0xad,0xab,0xa2,0x00,0xc3,0xc1,0xba,0x00,
+		0xf9,0xf1,0xde,0x00,0xff,0xce,0x3f,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xcc,0x3a,0x00,0xf9,0xee,0xcf,0x00,0xd8,0xd2,0xc0,0x00,0xbe,0xb2,0x92,0x00,0xbf,0xb3,0x90,0x00,
+		0xc0,0xb3,0x8f,0x00,0xc2,0xb4,0x8e,0x00,0xc3,0xb5,0x8d,0x00,0xc3,0xb6,0x8c,0x00,0xc5,0xb6,0x8b,0x00,0xc6,0xb7,0x8a,0x00,
+		0xc7,0xb7,0x8a,0x00,0xc7,0xb8,0x8a,0x00,0xc8,0xb8,0x89,0x00,0xc8,0xb8,0x89,0x00,0xc9,0xb8,0x89,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xca,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe7,0xd0,0x00,
+		0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfe,0xc5,0x26,0x00,0xfe,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xfd,0xc5,0x26,0x00,0xfd,0xc4,0x25,0x00,0xfd,0xc3,0x20,0x00,
+		0xfd,0xc0,0x15,0x00,0xfd,0xbe,0x0a,0x00,0xfd,0xbd,0x03,0x00,0xfd,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,
+		0xfc,0xc6,0x2a,0x00,0xf3,0xea,0xcf,0x00,0xbf,0xb7,0x9e,0x00,0xa6,0x9c,0x7c,0x00,0xa1,0x96,0x76,0x00,0x96,0x8b,0x6b,0x00,
+		0x8a,0x7f,0x5e,0x00,0x7d,0x71,0x50,0x00,0x6e,0x61,0x40,0x00,0x5f,0x54,0x31,0x00,0x54,0x47,0x23,0x00,0x4a,0x3d,0x18,0x00,
+		0x42,0x35,0x0f,0x00,0x3f,0x30,0x09,0x00,0x3c,0x2e,0x05,0x00,0x3d,0x2e,0x02,0x00,0x3e,0x2e,0x01,0x00,0x3f,0x2f,0x00,0x00,
+		0x41,0x31,0x00,0x00,0x43,0x32,0x00,0x00,0x44,0x33,0x00,0x00,0x47,0x34,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x48,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x49,0x36,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3b,0x2b,0x00,0x00,
+		0x38,0x29,0x00,0x00,0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x2f,0x23,0x00,0x00,0x2c,0x21,0x00,0x00,0x28,0x1e,0x00,0x00,
+		0x26,0x1d,0x00,0x00,0x23,0x1a,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x11,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,
+		0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x05,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,
+		0x0a,0x05,0x0b,0x00,0x0c,0x07,0x0e,0x00,0x0e,0x07,0x11,0x00,0x11,0x08,0x13,0x00,0x13,0x09,0x16,0x00,0x16,0x0a,0x19,0x00,
+		0x19,0x0c,0x1d,0x00,0x1d,0x0d,0x21,0x00,0x20,0x0f,0x26,0x00,0x24,0x10,0x29,0x00,0x28,0x12,0x2f,0x00,0x2c,0x13,0x32,0x00,
+		0x30,0x14,0x37,0x00,0x35,0x16,0x3c,0x00,0x38,0x18,0x41,0x00,0x3c,0x19,0x45,0x00,0x40,0x1a,0x4a,0x00,0x44,0x1c,0x4f,0x00,
+		0x47,0x1d,0x52,0x00,0x4b,0x20,0x57,0x00,0x4f,0x21,0x5b,0x00,0x53,0x24,0x5e,0x00,0x58,0x27,0x64,0x00,0x5e,0x2d,0x6b,0x00,
+		0x67,0x33,0x71,0x00,0x6f,0x3c,0x7a,0x00,0x79,0x45,0x84,0x00,0x83,0x4f,0x8e,0x00,0x8f,0x5b,0x99,0x00,0x99,0x64,0xa2,0x00,
+		0xa1,0x6e,0xaa,0x00,0xaa,0x76,0xb2,0x00,0xaf,0x7d,0xb7,0x00,0xb4,0x82,0xbb,0x00,0xb6,0x86,0xbc,0x00,0xfb,0xf3,0xfd,0x00,
+		0xca,0x51,0xee,0x00,0xbf,0x2c,0xeb,0x00,0xc1,0x34,0xec,0x00,0xc1,0x34,0xec,0x00,0xc2,0x34,0xed,0x00,0xc1,0x34,0xed,0x00,
+		0xc1,0x34,0xed,0x00,0xc1,0x34,0xec,0x00,0xbf,0x34,0xeb,0x00,0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,
+		0xbf,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,0xbe,0x34,0xec,0x00,0xbd,0x33,0xeb,0x00,0xbe,0x33,0xeb,0x00,0xbe,0x33,0xeb,0x00,
+		0xbf,0x33,0xec,0x00,0xc0,0x32,0xed,0x00,0xb5,0x31,0xe4,0x00,0xa3,0x37,0xd5,0x00,0xa7,0x44,0xd6,0x00,0xb9,0x46,0xe6,0x00,
+		0xc6,0x57,0xee,0x00,0xfd,0xe4,0xff,0x00,0xc6,0xff,0xec,0x00,0x4d,0xec,0xc1,0x00,0x48,0xe5,0xb2,0x00,0x36,0xda,0x94,0x00,
+		0x2c,0xd7,0x87,0x00,0x2e,0xda,0x90,0x00,0x31,0xdd,0x95,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,
+		0x31,0xdc,0x93,0x00,0x33,0xdd,0x95,0x00,0x35,0xdd,0x96,0x00,0x38,0xde,0x98,0x00,0x39,0xde,0x99,0x00,0x3b,0xde,0x9b,0x00,
+		0x3e,0xdf,0x9c,0x00,0x40,0xe0,0x9d,0x00,0x43,0xe0,0x9f,0x00,0x45,0xe0,0xa0,0x00,0x47,0xe1,0xa2,0x00,0x49,0xe1,0xa3,0x00,
+		0x4a,0xe1,0xa4,0x00,0x4d,0xe2,0xa6,0x00,0x43,0xe1,0xa2,0x00,0x96,0xee,0xcb,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,
+		0x9b,0xae,0xa6,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,0x9c,0xa7,0xa4,0x00,0x9c,0xa6,0xa2,0x00,
+		0x9c,0xa4,0xa1,0x00,0x9b,0xa2,0xa0,0x00,0x9b,0xa0,0x9f,0x00,0x9a,0x9f,0x9d,0x00,0x99,0x9d,0x9c,0x00,0x98,0x9b,0x9a,0x00,
+		0x97,0x99,0x99,0x00,0xa4,0xa5,0xa5,0x00,0xd0,0xd1,0xd1,0x00,0xea,0xea,0xea,0x00,0xcd,0xcd,0xce,0x00,0x7c,0x7d,0x80,0x00,
+		0x4d,0x50,0x53,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0xa9,0xaa,0xac,0x00,0xe9,0xea,0xea,0x00,
+		0x99,0x9a,0x9a,0x00,0xbe,0xbf,0xc0,0x00,0xc5,0xc6,0xc7,0x00,0x4b,0x4d,0x51,0x00,0x54,0x57,0x5a,0x00,0x5e,0x61,0x63,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x63,0x65,0x68,0x00,0x6a,0x6c,0x6e,0x00,0x7e,0x7f,0x82,0x00,0xc1,0xc2,0xc3,0x00,0xeb,0xeb,0xeb,0x00,0xd6,0xd6,0xd7,0x00,
+		0xa6,0xa6,0xa7,0x00,0x9b,0x9c,0x9c,0x00,0x9d,0x9d,0x9d,0x00,0x9d,0x9d,0x9d,0x00,0xc1,0xc1,0xc0,0x00,0xf6,0xec,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xf0,0xea,0xda,0x00,0xae,0xac,0xa3,0x00,0xbc,0xb9,0xb1,0x00,0xf6,0xf1,0xe1,0x00,0xff,0xd4,0x59,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc8,0x2a,0x00,
+		0xfb,0xec,0xc2,0x00,0xe4,0xe0,0xd2,0x00,0xbe,0xb2,0x93,0x00,0xbf,0xb3,0x91,0x00,0xc1,0xb3,0x90,0x00,0xc2,0xb4,0x8e,0x00,
+		0xc3,0xb5,0x8d,0x00,0xc4,0xb5,0x8c,0x00,0xc5,0xb6,0x8b,0x00,0xc6,0xb7,0x8b,0x00,0xc7,0xb7,0x8a,0x00,0xc7,0xb8,0x8a,0x00,
+		0xc8,0xb8,0x8a,0x00,0xc8,0xb8,0x89,0x00,0xc9,0xb8,0x89,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,
+		0xc9,0xb9,0x8a,0x00,0xc9,0xb9,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe7,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xfd,0xc8,0x34,0x00,
+		0xfc,0xd9,0x75,0x00,0xfd,0xdc,0x7f,0x00,0xfd,0xdb,0x79,0x00,0xfc,0xd8,0x70,0x00,0xfd,0xd7,0x6d,0x00,0xfd,0xd7,0x6c,0x00,
+		0xfc,0xd6,0x6a,0x00,0xfc,0xd6,0x6a,0x00,0xfb,0xd5,0x6a,0x00,0xfc,0xd6,0x68,0x00,0xfd,0xdb,0x77,0x00,0xf5,0xec,0xd4,0x00,
+		0xbf,0xb6,0x9d,0x00,0xa8,0x9d,0x7d,0x00,0x9f,0x95,0x75,0x00,0x96,0x8b,0x6b,0x00,0x8b,0x7f,0x60,0x00,0x7d,0x71,0x51,0x00,
+		0x6e,0x61,0x41,0x00,0x60,0x53,0x31,0x00,0x54,0x48,0x23,0x00,0x4a,0x3d,0x18,0x00,0x43,0x35,0x0f,0x00,0x3f,0x30,0x09,0x00,
+		0x3d,0x2e,0x05,0x00,0x3c,0x2e,0x02,0x00,0x3d,0x2e,0x01,0x00,0x3e,0x2e,0x00,0x00,0x41,0x30,0x00,0x00,0x43,0x32,0x00,0x00,
+		0x45,0x32,0x00,0x00,0x45,0x33,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x48,0x36,0x00,0x00,0x49,0x36,0x00,0x00,
+		0x49,0x36,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x47,0x35,0x00,0x00,0x46,0x33,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x42,0x31,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3b,0x2b,0x00,0x00,0x38,0x29,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2b,0x20,0x00,0x00,0x29,0x1e,0x00,0x00,0x25,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,
+		0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x1a,0x13,0x00,0x00,0x17,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,
+		0x05,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,
+		0x0e,0x07,0x11,0x00,0x11,0x08,0x13,0x00,0x13,0x09,0x15,0x00,0x16,0x0a,0x1a,0x00,0x19,0x0c,0x1d,0x00,0x1d,0x0d,0x21,0x00,
+		0x20,0x0f,0x26,0x00,0x24,0x10,0x29,0x00,0x28,0x12,0x2f,0x00,0x2c,0x13,0x33,0x00,0x30,0x14,0x37,0x00,0x34,0x16,0x3d,0x00,
+		0x39,0x18,0x42,0x00,0x3c,0x19,0x45,0x00,0x3f,0x1a,0x4a,0x00,0x43,0x1c,0x4e,0x00,0x47,0x1d,0x51,0x00,0x4b,0x1f,0x56,0x00,
+		0x4e,0x21,0x5a,0x00,0x52,0x24,0x5e,0x00,0x57,0x27,0x64,0x00,0x5e,0x2c,0x6b,0x00,0x65,0x33,0x73,0x00,0x6f,0x3b,0x7b,0x00,
+		0x79,0x45,0x84,0x00,0x83,0x4e,0x8f,0x00,0x8f,0x5a,0x9a,0x00,0x98,0x64,0xa3,0x00,0xa0,0x6d,0xab,0x00,0xa9,0x76,0xb2,0x00,
+		0xad,0x7b,0xb6,0x00,0xb3,0x81,0xbc,0x00,0xb5,0x85,0xbe,0x00,0xf9,0xf1,0xfb,0x00,0xc9,0x51,0xed,0x00,0xbd,0x2c,0xe9,0x00,
+		0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,0xc0,0x34,0xec,0x00,0xbf,0x34,0xec,0x00,
+		0xbd,0x34,0xeb,0x00,0xbe,0x33,0xeb,0x00,0xbd,0x33,0xea,0x00,0xbd,0x33,0xea,0x00,0xbe,0x34,0xeb,0x00,0xbe,0x33,0xeb,0x00,
+		0xbd,0x33,0xeb,0x00,0xbd,0x33,0xea,0x00,0xbe,0x34,0xeb,0x00,0xc0,0x32,0xed,0x00,0xb8,0x31,0xe8,0x00,0xa6,0x35,0xd8,0x00,
+		0xa5,0x44,0xd4,0x00,0xba,0x51,0xe4,0x00,0xc8,0x54,0xee,0x00,0xc1,0x4a,0xec,0x00,0xc5,0x59,0xec,0x00,0xfe,0xe5,0xff,0x00,
+		0xc6,0xff,0xea,0x00,0x4c,0xea,0xbe,0x00,0x52,0xeb,0xc2,0x00,0x52,0xeb,0xc1,0x00,0x45,0xe2,0xaa,0x00,0x33,0xd8,0x8e,0x00,
+		0x2b,0xd7,0x89,0x00,0x30,0xdc,0x92,0x00,0x31,0xdd,0x94,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,
+		0x32,0xdc,0x94,0x00,0x36,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x39,0xde,0x99,0x00,0x3c,0xde,0x9a,0x00,0x3f,0xdf,0x9c,0x00,
+		0x40,0xe0,0x9d,0x00,0x43,0xe0,0x9f,0x00,0x45,0xe0,0xa0,0x00,0x47,0xe0,0xa2,0x00,0x48,0xe0,0xa2,0x00,0x4b,0xe1,0xa5,0x00,
+		0x41,0xe0,0xa0,0x00,0x94,0xed,0xc9,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xae,0xa6,0x00,0x9b,0xad,0xa6,0x00,
+		0x9b,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,0x9c,0xa7,0xa3,0x00,0x9c,0xa6,0xa2,0x00,0x9c,0xa4,0xa1,0x00,0x9b,0xa2,0xa0,0x00,
+		0x9b,0xa0,0x9e,0x00,0x9a,0x9f,0x9e,0x00,0x99,0x9d,0x9c,0x00,0x98,0x9b,0x9b,0x00,0x97,0x9a,0x9a,0x00,0x96,0x98,0x98,0x00,
+		0x95,0x97,0x97,0x00,0xaf,0xb0,0xb0,0x00,0xda,0xdb,0xdb,0x00,0xe8,0xe8,0xe8,0x00,0xc8,0xc9,0xca,0x00,0x84,0x86,0x88,0x00,
+		0x4f,0x51,0x55,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x5a,0x5c,0x5f,0x00,0xdb,0xdc,0xdc,0x00,0xc2,0xc3,0xc3,0x00,0xbf,0xbf,0xc0,0x00,
+		0xc7,0xc8,0xc9,0x00,0x58,0x5a,0x5e,0x00,0x61,0x64,0x66,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x63,0x65,0x68,0x00,0x8b,0x8c,0x8f,0x00,0xb2,0xb2,0xb4,0x00,0xb0,0xb2,0xb2,0x00,0xb0,0xb1,0xb2,0x00,
+		0xb0,0xb1,0xb2,0x00,0xb0,0xb2,0xb2,0x00,0xb0,0xb2,0xb2,0x00,0xad,0xae,0xb0,0x00,0xc7,0xc8,0xc9,0x00,0xd2,0xd3,0xd4,0x00,
+		0xe5,0xe5,0xe6,0x00,0xe8,0xe8,0xe8,0x00,0xbe,0xbf,0xbf,0x00,0x9c,0x9d,0x9e,0x00,0x9b,0x9c,0x9c,0x00,0x9b,0x9c,0x9d,0x00,
+		0x9c,0x9d,0x9d,0x00,0x9e,0x9e,0x9e,0x00,0xc2,0xc1,0xc1,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf0,0xea,0xda,0x00,
+		0xb0,0xac,0xa6,0x00,0xb4,0xb2,0xa9,0x00,0xf1,0xed,0xe0,0x00,0xff,0xdb,0x76,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfd,0xe2,0x94,0x00,0xf3,0xef,0xe4,0x00,
+		0xc5,0xba,0x9d,0x00,0xbf,0xb4,0x91,0x00,0xc1,0xb4,0x90,0x00,0xc2,0xb4,0x8f,0x00,0xc3,0xb5,0x8d,0x00,0xc4,0xb6,0x8c,0x00,
+		0xc5,0xb6,0x8c,0x00,0xc6,0xb7,0x8b,0x00,0xc7,0xb8,0x8a,0x00,0xc7,0xb8,0x8a,0x00,0xc7,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb8,0x89,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,
+		0xc9,0xb8,0x8a,0x00,0xf0,0xe8,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xfb,0xe1,0x96,0x00,0xf7,0xf2,0xe1,0x00,0xf0,0xe8,0xd3,0x00,
+		0xef,0xe7,0xd2,0x00,0xef,0xe7,0xd1,0x00,0xee,0xe7,0xd1,0x00,0xee,0xe7,0xd2,0x00,0xee,0xe7,0xd2,0x00,0xee,0xe7,0xd2,0x00,
+		0xed,0xe5,0xd2,0x00,0xef,0xe7,0xd3,0x00,0xee,0xe7,0xd2,0x00,0xe6,0xe0,0xcd,0x00,0xbb,0xb1,0x96,0x00,0xa9,0x9d,0x7e,0x00,
+		0xa1,0x96,0x76,0x00,0x97,0x8c,0x6c,0x00,0x8b,0x80,0x5f,0x00,0x7e,0x73,0x51,0x00,0x6e,0x63,0x41,0x00,0x61,0x55,0x31,0x00,
+		0x54,0x48,0x24,0x00,0x4a,0x3e,0x18,0x00,0x44,0x36,0x10,0x00,0x3e,0x31,0x09,0x00,0x3c,0x2e,0x05,0x00,0x3d,0x2e,0x02,0x00,
+		0x3e,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,0x40,0x2f,0x00,0x00,0x43,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x46,0x33,0x00,0x00,
+		0x47,0x34,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x47,0x35,0x00,0x00,0x48,0x36,0x00,0x00,0x48,0x36,0x00,0x00,
+		0x48,0x35,0x00,0x00,0x47,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x43,0x31,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,0x38,0x29,0x00,0x00,0x34,0x26,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,
+		0x2c,0x21,0x00,0x00,0x29,0x1f,0x00,0x00,0x26,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x1a,0x13,0x00,0x00,0x16,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,0x03,0x01,0x03,0x00,0x04,0x02,0x04,0x00,0x04,0x02,0x05,0x00,0x05,0x03,0x06,0x00,
+		0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0e,0x07,0x11,0x00,0x10,0x08,0x13,0x00,
+		0x13,0x09,0x16,0x00,0x16,0x0a,0x1a,0x00,0x19,0x0c,0x1e,0x00,0x1c,0x0d,0x21,0x00,0x20,0x0f,0x26,0x00,0x24,0x10,0x29,0x00,
+		0x28,0x12,0x2e,0x00,0x2c,0x13,0x33,0x00,0x30,0x14,0x37,0x00,0x33,0x16,0x3c,0x00,0x37,0x18,0x40,0x00,0x3b,0x19,0x45,0x00,
+		0x40,0x1b,0x4a,0x00,0x42,0x1c,0x4e,0x00,0x47,0x1d,0x51,0x00,0x4a,0x1f,0x56,0x00,0x4f,0x21,0x5b,0x00,0x52,0x24,0x5e,0x00,
+		0x57,0x27,0x64,0x00,0x5e,0x2c,0x6a,0x00,0x64,0x33,0x72,0x00,0x6f,0x3b,0x7c,0x00,0x79,0x45,0x86,0x00,0x83,0x4e,0x8f,0x00,
+		0x8f,0x5b,0x9b,0x00,0x97,0x63,0xa3,0x00,0xa0,0x6d,0xac,0x00,0xaa,0x75,0xb4,0x00,0xad,0x7b,0xb7,0x00,0xb2,0x80,0xbc,0x00,
+		0xb5,0x85,0xbf,0x00,0xfb,0xf3,0xfd,0x00,0xc9,0x52,0xee,0x00,0xbc,0x2c,0xe9,0x00,0xbe,0x34,0xea,0x00,0xbe,0x34,0xeb,0x00,
+		0xbe,0x34,0xeb,0x00,0xbe,0x34,0xeb,0x00,0xbe,0x34,0xeb,0x00,0xbe,0x34,0xeb,0x00,0xbe,0x33,0xeb,0x00,0xbd,0x33,0xeb,0x00,
+		0xbd,0x34,0xeb,0x00,0xbd,0x33,0xeb,0x00,0xbc,0x33,0xe9,0x00,0xbd,0x33,0xeb,0x00,0xbd,0x33,0xea,0x00,0xbf,0x33,0xec,0x00,
+		0xbb,0x31,0xea,0x00,0xaa,0x32,0xdc,0x00,0xa3,0x41,0xd3,0x00,0xb9,0x55,0xe0,0x00,0xcc,0x5c,0xef,0x00,0xcb,0x5a,0xf0,0x00,
+		0xc7,0x56,0xed,0x00,0xc3,0x4d,0xec,0x00,0xc8,0x5d,0xec,0x00,0xfe,0xe5,0xff,0x00,0xc6,0xfe,0xea,0x00,0x4d,0xea,0xbf,0x00,
+		0x52,0xeb,0xc0,0x00,0x52,0xeb,0xc0,0x00,0x54,0xec,0xc4,0x00,0x50,0xea,0xbd,0x00,0x3f,0xe0,0xa2,0x00,0x2f,0xd7,0x8a,0x00,
+		0x2c,0xd9,0x8b,0x00,0x31,0xdc,0x94,0x00,0x31,0xdc,0x94,0x00,0x31,0xdc,0x93,0x00,0x31,0xdc,0x93,0x00,0x33,0xdc,0x95,0x00,
+		0x36,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x3a,0xde,0x99,0x00,0x3c,0xde,0x9b,0x00,0x3d,0xdf,0x9c,0x00,0x40,0xdf,0x9d,0x00,
+		0x43,0xe0,0x9f,0x00,0x44,0xe0,0xa0,0x00,0x47,0xe0,0xa1,0x00,0x49,0xe1,0xa3,0x00,0x3f,0xdf,0x9f,0x00,0x93,0xed,0xc9,0x00,
+		0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xaf,0xa6,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,
+		0x9c,0xa8,0xa3,0x00,0x9c,0xa6,0xa2,0x00,0x9c,0xa4,0xa1,0x00,0x9c,0xa2,0xa0,0x00,0x9b,0xa1,0x9f,0x00,0x9a,0x9f,0x9d,0x00,
+		0x99,0x9d,0x9c,0x00,0x99,0x9c,0x9b,0x00,0x98,0x9a,0x9a,0x00,0x96,0x99,0x98,0x00,0x95,0x97,0x97,0x00,0x94,0x96,0x96,0x00,
+		0x96,0x98,0x98,0x00,0xb5,0xb6,0xb6,0x00,0xdb,0xdb,0xdb,0x00,0xe8,0xe8,0xe9,0x00,0xce,0xcf,0xd0,0x00,0x6d,0x6f,0x72,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0xab,0xac,0xae,0x00,0xd6,0xd7,0xd7,0x00,0xc2,0xc3,0xc4,0x00,0xcc,0xcd,0xce,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x80,0x82,0x84,0x00,
+		0xd9,0xd9,0xda,0x00,0xe0,0xe0,0xe0,0x00,0xd8,0xd8,0xd9,0x00,0xd9,0xda,0xda,0x00,0xd9,0xda,0xda,0x00,0xd9,0xda,0xda,0x00,
+		0xda,0xda,0xda,0x00,0xda,0xda,0xda,0x00,0xda,0xda,0xda,0x00,0xc9,0xc9,0xc9,0x00,0xc1,0xc2,0xc2,0x00,0xa5,0xa5,0xa6,0x00,
+		0x9a,0x9b,0x9b,0x00,0x9b,0x9b,0x9c,0x00,0x9b,0x9c,0x9d,0x00,0x9c,0x9d,0x9d,0x00,0x9d,0x9d,0x9e,0x00,0x9e,0x9e,0x9e,0x00,
+		0xc2,0xc2,0xc1,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf0,0xea,0xda,0x00,0xb2,0xb0,0xa8,0x00,0xad,0xab,0xa1,0x00,
+		0xeb,0xe7,0xde,0x00,0xfe,0xe3,0x95,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xd1,0x4d,0x00,0xf9,0xf2,0xe0,0x00,0xe2,0xdd,0xce,0x00,0xc2,0xb5,0x95,0x00,
+		0xc1,0xb4,0x90,0x00,0xc2,0xb4,0x8f,0x00,0xc3,0xb5,0x8e,0x00,0xc4,0xb6,0x8d,0x00,0xc5,0xb6,0x8c,0x00,0xc6,0xb7,0x8b,0x00,
+		0xc7,0xb7,0x8b,0x00,0xc7,0xb8,0x8a,0x00,0xc8,0xb8,0x8a,0x00,0xc8,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,0xc9,0xb8,0x8a,0x00,
+		0xce,0xbe,0x94,0x00,0xd4,0xc5,0x9f,0x00,0xd1,0xc3,0x9b,0x00,0xc9,0xba,0x8b,0x00,0xc9,0xb8,0x8a,0x00,0xf0,0xe8,0xd0,0x00,
+		0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfe,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xfe,0xc5,0x24,0x00,
+		0xfe,0xc4,0x1d,0x00,0xf9,0xe7,0xb5,0x00,0xdf,0xd6,0xbe,0x00,0xbb,0xad,0x80,0x00,0xbc,0xac,0x82,0x00,0xbb,0xac,0x83,0x00,
+		0xba,0xac,0x84,0x00,0xb9,0xac,0x85,0x00,0xb9,0xab,0x87,0x00,0xb8,0xac,0x87,0x00,0xb8,0xac,0x89,0x00,0xb7,0xaa,0x89,0x00,
+		0xb6,0xaa,0x89,0x00,0xb2,0xa6,0x87,0x00,0xaf,0xa3,0x83,0x00,0xaa,0x9e,0x7e,0x00,0xa2,0x97,0x77,0x00,0x98,0x8d,0x6c,0x00,
+		0x8c,0x80,0x60,0x00,0x7e,0x72,0x52,0x00,0x70,0x64,0x42,0x00,0x62,0x56,0x33,0x00,0x54,0x47,0x24,0x00,0x4b,0x3e,0x19,0x00,
+		0x44,0x36,0x10,0x00,0x3e,0x31,0x09,0x00,0x3d,0x2e,0x05,0x00,0x3b,0x2d,0x02,0x00,0x3e,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,
+		0x40,0x2f,0x00,0x00,0x42,0x31,0x00,0x00,0x44,0x32,0x00,0x00,0x46,0x34,0x00,0x00,0x47,0x34,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x49,0x36,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x47,0x34,0x00,0x00,0x48,0x35,0x00,0x00,0x47,0x35,0x00,0x00,
+		0x45,0x33,0x00,0x00,0x43,0x31,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x2f,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,
+		0x38,0x29,0x00,0x00,0x34,0x27,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2c,0x21,0x00,0x00,0x29,0x1f,0x00,0x00,
+		0x25,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x11,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x03,0x00,
+		0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,
+		0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0e,0x06,0x10,0x00,0x11,0x08,0x13,0x00,0x13,0x09,0x16,0x00,0x16,0x0a,0x19,0x00,
+		0x19,0x0c,0x1d,0x00,0x1c,0x0d,0x21,0x00,0x20,0x0f,0x25,0x00,0x24,0x10,0x2a,0x00,0x27,0x11,0x2d,0x00,0x2c,0x13,0x33,0x00,
+		0x30,0x15,0x37,0x00,0x34,0x16,0x3c,0x00,0x38,0x18,0x40,0x00,0x3c,0x19,0x45,0x00,0x40,0x1b,0x49,0x00,0x43,0x1c,0x4d,0x00,
+		0x47,0x1d,0x52,0x00,0x4a,0x1f,0x56,0x00,0x4e,0x21,0x5a,0x00,0x53,0x24,0x5f,0x00,0x57,0x27,0x64,0x00,0x5e,0x2c,0x6b,0x00,
+		0x65,0x33,0x72,0x00,0x6e,0x3b,0x7b,0x00,0x78,0x44,0x85,0x00,0x84,0x4f,0x90,0x00,0x8e,0x5b,0x9b,0x00,0x98,0x64,0xa4,0x00,
+		0xa0,0x6d,0xac,0x00,0xa9,0x75,0xb4,0x00,0xaf,0x7c,0xba,0x00,0xb3,0x81,0xbe,0x00,0xb5,0x84,0xbf,0x00,0xfa,0xf2,0xfc,0x00,
+		0xc6,0x51,0xec,0x00,0xba,0x2b,0xe9,0x00,0xbd,0x34,0xe9,0x00,0xbd,0x34,0xe9,0x00,0xbd,0x34,0xea,0x00,0xbc,0x33,0xea,0x00,
+		0xbd,0x34,0xeb,0x00,0xbd,0x33,0xeb,0x00,0xbd,0x33,0xeb,0x00,0xbc,0x33,0xea,0x00,0xbc,0x33,0xea,0x00,0xbc,0x33,0xea,0x00,
+		0xbb,0x33,0xeb,0x00,0xbd,0x33,0xec,0x00,0xbc,0x31,0xeb,0x00,0xad,0x30,0xdf,0x00,0xa2,0x3c,0xd3,0x00,0xb4,0x54,0xdd,0x00,
+		0xce,0x63,0xee,0x00,0xd1,0x61,0xf2,0x00,0xcd,0x5d,0xef,0x00,0xca,0x5b,0xee,0x00,0xc9,0x59,0xee,0x00,0xc5,0x51,0xed,0x00,
+		0xca,0x5f,0xee,0x00,0xff,0xe6,0xff,0x00,0xc6,0xff,0xeb,0x00,0x4d,0xeb,0xc0,0x00,0x51,0xeb,0xc1,0x00,0x53,0xec,0xc1,0x00,
+		0x52,0xeb,0xc0,0x00,0x51,0xeb,0xc1,0x00,0x53,0xec,0xc3,0x00,0x4d,0xe8,0xb8,0x00,0x3a,0xdc,0x9a,0x00,0x2d,0xd6,0x88,0x00,
+		0x2d,0xd9,0x8e,0x00,0x31,0xdd,0x94,0x00,0x31,0xdc,0x94,0x00,0x31,0xdc,0x93,0x00,0x32,0xdc,0x94,0x00,0x35,0xdd,0x96,0x00,
+		0x38,0xdd,0x97,0x00,0x3a,0xde,0x99,0x00,0x3b,0xde,0x9a,0x00,0x3e,0xdf,0x9c,0x00,0x3f,0xdf,0x9d,0x00,0x42,0xe0,0x9f,0x00,
+		0x45,0xdf,0x9f,0x00,0x47,0xe1,0xa1,0x00,0x3d,0xdf,0x9d,0x00,0x92,0xed,0xc8,0x00,0xf5,0xf8,0xf7,0x00,0xaa,0xbd,0xb5,0x00,
+		0x9a,0xaf,0xa7,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,0x9c,0xa8,0xa3,0x00,0x9c,0xa6,0xa3,0x00,
+		0x9c,0xa4,0xa1,0x00,0x9c,0xa3,0xa0,0x00,0x9b,0xa0,0x9f,0x00,0xab,0xaf,0xae,0x00,0xc5,0xc7,0xc7,0x00,0xc7,0xc9,0xc8,0x00,
+		0xa6,0xa9,0xa9,0x00,0x96,0x99,0x99,0x00,0x96,0x97,0x97,0x00,0x95,0x96,0x96,0x00,0x93,0x94,0x95,0x00,0x93,0x93,0x94,0x00,
+		0x94,0x95,0x96,0x00,0xad,0xae,0xaf,0x00,0xd8,0xd9,0xd9,0x00,0xd7,0xd8,0xd8,0x00,0x5a,0x5c,0x60,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4a,0x4e,0x00,0x94,0x96,0x98,0x00,
+		0xdc,0xdc,0xdc,0x00,0xcc,0xcd,0xcd,0x00,0xce,0xce,0xce,0x00,0x62,0x64,0x67,0x00,0x62,0x65,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x8b,0x8c,0x8f,0x00,0xe3,0xe3,0xe3,0x00,0xac,0xac,0xac,0x00,
+		0x9b,0x9b,0x9b,0x00,0x9b,0x9b,0x9c,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x99,0x9a,0x9b,0x00,
+		0x98,0x99,0x9a,0x00,0x97,0x98,0x99,0x00,0x98,0x98,0x99,0x00,0x98,0x99,0x99,0x00,0x9a,0x9a,0x9b,0x00,0x9b,0x9b,0x9b,0x00,
+		0x9b,0x9b,0x9c,0x00,0x9c,0x9c,0x9d,0x00,0x9e,0x9e,0x9e,0x00,0x9f,0x9f,0x9f,0x00,0xc3,0xc2,0xc1,0x00,0xf6,0xec,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xf0,0xea,0xda,0x00,0xb2,0xb1,0xa9,0x00,0xac,0xa9,0xa0,0x00,0xe2,0xe0,0xd9,0x00,0xfc,0xe8,0xb1,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xfc,0xd9,0x70,0x00,0xf8,0xf4,0xe5,0x00,0xe4,0xdf,0xd0,0x00,0xc4,0xb9,0x97,0x00,0xc3,0xb5,0x90,0x00,
+		0xc3,0xb5,0x8f,0x00,0xc4,0xb6,0x8e,0x00,0xc5,0xb6,0x8d,0x00,0xc6,0xb7,0x8c,0x00,0xc6,0xb7,0x8b,0x00,0xc7,0xb8,0x8b,0x00,
+		0xc7,0xb8,0x8a,0x00,0xc9,0xb8,0x8b,0x00,0xc9,0xb8,0x8b,0x00,0xd9,0xcd,0xac,0x00,0xf1,0xeb,0xdd,0x00,0xf7,0xf1,0xdb,0x00,
+		0xe8,0xdf,0xc3,0x00,0xc9,0xb9,0x8b,0x00,0xc9,0xb9,0x8a,0x00,0xf0,0xe7,0xd0,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x25,0x00,0xff,0xc5,0x1f,0x00,0xff,0xc1,0x12,0x00,0xfe,0xbe,0x07,0x00,0xfb,0xe6,0xac,0x00,
+		0xdf,0xd5,0xb9,0x00,0xba,0xaa,0x7e,0x00,0xba,0xaa,0x7f,0x00,0xb9,0xaa,0x80,0x00,0xb8,0xaa,0x81,0x00,0xb7,0xaa,0x82,0x00,
+		0xb7,0xaa,0x84,0x00,0xb6,0xaa,0x84,0x00,0xb6,0xa9,0x85,0x00,0xb4,0xa7,0x84,0x00,0xb3,0xa8,0x85,0x00,0xb3,0xa7,0x85,0x00,
+		0xaf,0xa4,0x82,0x00,0xaa,0x9e,0x7e,0x00,0xa4,0x99,0x78,0x00,0x99,0x8d,0x6c,0x00,0x8e,0x82,0x61,0x00,0x7f,0x73,0x52,0x00,
+		0x71,0x64,0x43,0x00,0x63,0x57,0x34,0x00,0x58,0x4b,0x26,0x00,0x4c,0x3f,0x1a,0x00,0x45,0x37,0x11,0x00,0x3e,0x31,0x09,0x00,
+		0x3d,0x2f,0x05,0x00,0x3c,0x2d,0x02,0x00,0x3c,0x2d,0x01,0x00,0x3f,0x2f,0x01,0x00,0x40,0x30,0x00,0x00,0x42,0x30,0x00,0x00,
+		0x43,0x32,0x00,0x00,0x45,0x32,0x00,0x00,0x46,0x33,0x00,0x00,0x47,0x34,0x00,0x00,0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,
+		0x48,0x35,0x00,0x00,0x48,0x35,0x00,0x00,0x47,0x34,0x00,0x00,0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x42,0x31,0x00,0x00,
+		0x41,0x2f,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3a,0x2b,0x00,0x00,0x36,0x28,0x00,0x00,0x34,0x26,0x00,0x00,
+		0x31,0x23,0x00,0x00,0x2f,0x23,0x00,0x00,0x2c,0x21,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1b,0x00,0x00,0x22,0x1a,0x00,0x00,
+		0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,
+		0x04,0x02,0x05,0x00,0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,
+		0x0e,0x06,0x10,0x00,0x11,0x08,0x13,0x00,0x13,0x09,0x16,0x00,0x15,0x0a,0x19,0x00,0x19,0x0c,0x1d,0x00,0x1c,0x0d,0x21,0x00,
+		0x20,0x0f,0x25,0x00,0x24,0x10,0x2a,0x00,0x27,0x11,0x2d,0x00,0x2b,0x13,0x32,0x00,0x2f,0x15,0x36,0x00,0x33,0x17,0x3c,0x00,
+		0x38,0x18,0x41,0x00,0x3b,0x19,0x44,0x00,0x3e,0x1b,0x49,0x00,0x42,0x1c,0x4e,0x00,0x45,0x1d,0x51,0x00,0x4b,0x20,0x57,0x00,
+		0x4e,0x21,0x5b,0x00,0x53,0x24,0x60,0x00,0x57,0x27,0x64,0x00,0x5e,0x2c,0x6b,0x00,0x65,0x34,0x73,0x00,0x6e,0x3b,0x7c,0x00,
+		0x78,0x45,0x85,0x00,0x84,0x50,0x91,0x00,0x8d,0x5a,0x9b,0x00,0x98,0x63,0xa4,0x00,0xa2,0x6e,0xaf,0x00,0xa8,0x75,0xb4,0x00,
+		0xae,0x7c,0xba,0x00,0xb2,0x80,0xbe,0x00,0xb5,0x84,0xc0,0x00,0xf9,0xf1,0xfb,0x00,0xc7,0x52,0xed,0x00,0xba,0x2b,0xe8,0x00,
+		0xbe,0x34,0xeb,0x00,0xbc,0x34,0xea,0x00,0xbc,0x33,0xe9,0x00,0xbc,0x33,0xe9,0x00,0xbd,0x33,0xea,0x00,0xbb,0x33,0xe9,0x00,
+		0xbb,0x33,0xea,0x00,0xbb,0x33,0xea,0x00,0xbb,0x33,0xea,0x00,0xbc,0x33,0xeb,0x00,0xbd,0x32,0xed,0x00,0xb1,0x2f,0xe4,0x00,
+		0xa2,0x38,0xd5,0x00,0xaf,0x52,0xd9,0x00,0xce,0x67,0xed,0x00,0xd7,0x6a,0xf5,0x00,0xd3,0x65,0xf1,0x00,0xd0,0x63,0xf0,0x00,
+		0xcf,0x61,0xf0,0x00,0xcd,0x5f,0xef,0x00,0xcb,0x5d,0xee,0x00,0xc8,0x55,0xed,0x00,0xcc,0x63,0xee,0x00,0xff,0xe6,0xff,0x00,
+		0xc6,0xff,0xeb,0x00,0x4e,0xeb,0xc1,0x00,0x52,0xec,0xc2,0x00,0x53,0xec,0xc2,0x00,0x53,0xeb,0xc1,0x00,0x52,0xeb,0xc0,0x00,
+		0x51,0xea,0xbf,0x00,0x53,0xec,0xc2,0x00,0x53,0xec,0xc1,0x00,0x48,0xe5,0xb1,0x00,0x35,0xd9,0x92,0x00,0x2c,0xd7,0x88,0x00,
+		0x2f,0xdb,0x90,0x00,0x31,0xdd,0x94,0x00,0x31,0xdc,0x93,0x00,0x33,0xdc,0x95,0x00,0x35,0xdd,0x96,0x00,0x38,0xde,0x98,0x00,
+		0x39,0xde,0x99,0x00,0x3b,0xdf,0x9b,0x00,0x3e,0xdf,0x9c,0x00,0x40,0xdf,0x9e,0x00,0x42,0xdf,0x9e,0x00,0x45,0xe0,0xa0,0x00,
+		0x3c,0xdf,0x9c,0x00,0x91,0xec,0xc7,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9a,0xaf,0xa6,0x00,0x9b,0xad,0xa6,0x00,
+		0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa4,0x00,0x9d,0xa8,0xa4,0x00,0x9d,0xa6,0xa2,0x00,0x9c,0xa4,0xa1,0x00,0x9c,0xa3,0xa0,0x00,
+		0x9b,0xa1,0x9f,0x00,0xb4,0xb7,0xb7,0x00,0xe2,0xe2,0xe2,0x00,0xdf,0xdf,0xe0,0x00,0xeb,0xeb,0xeb,0x00,0xc7,0xc8,0xc8,0x00,
+		0xa1,0xa3,0xa3,0x00,0x95,0x96,0x96,0x00,0x94,0x95,0x95,0x00,0x93,0x94,0x94,0x00,0x92,0x92,0x93,0x00,0x91,0x91,0x92,0x00,
+		0xa1,0xa1,0xa2,0x00,0xea,0xea,0xea,0x00,0x99,0x9a,0x9c,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x49,0x4b,0x4f,0x00,0x50,0x53,0x55,0x00,0x8f,0x91,0x92,0x00,0xdb,0xdb,0xdc,0x00,0xd0,0xd1,0xd1,0x00,
+		0xcd,0xce,0xce,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x65,0x68,0x00,0x89,0x8a,0x8d,0x00,0xe0,0xe1,0xe1,0x00,0xaa,0xab,0xab,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9a,0x9b,0x00,
+		0x98,0x99,0x9a,0x00,0x97,0x98,0x99,0x00,0x96,0x97,0x98,0x00,0x96,0x97,0x98,0x00,0x95,0x96,0x96,0x00,0x95,0x96,0x97,0x00,
+		0x95,0x96,0x97,0x00,0x96,0x96,0x97,0x00,0x97,0x99,0x99,0x00,0x99,0x9a,0x9a,0x00,0x9b,0x9b,0x9b,0x00,0x9c,0x9c,0x9d,0x00,
+		0x9e,0x9e,0x9f,0x00,0x9f,0x9f,0xa0,0x00,0xc3,0xc3,0xc1,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf0,0xeb,0xda,0x00,
+		0xb4,0xb2,0xab,0x00,0xad,0xaa,0xa1,0x00,0xd6,0xd4,0xce,0x00,0xf8,0xef,0xd4,0x00,0xff,0xcc,0x3b,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xd8,0x68,0x00,0xf9,0xf3,0xe2,0x00,0xeb,0xe6,0xda,0x00,0xd0,0xc7,0xab,0x00,0xca,0xbe,0x9d,0x00,0xc5,0xb8,0x92,0x00,
+		0xc4,0xb7,0x8e,0x00,0xc5,0xb7,0x8d,0x00,0xc6,0xb7,0x8c,0x00,0xc9,0xbb,0x92,0x00,0xd0,0xc3,0x9f,0x00,0xdd,0xd4,0xb8,0x00,
+		0xed,0xe6,0xd4,0x00,0xf8,0xf4,0xe6,0x00,0xfb,0xea,0xb8,0x00,0xfd,0xe9,0xae,0x00,0xeb,0xe1,0xc8,0x00,0xc9,0xb8,0x8b,0x00,
+		0xc9,0xb8,0x8b,0x00,0xf0,0xe7,0xd1,0x00,0xfd,0xe1,0x92,0x00,0xff,0xc7,0x25,0x00,0xfe,0xc5,0x21,0x00,0xfe,0xc2,0x16,0x00,
+		0xff,0xc0,0x0b,0x00,0xff,0xbd,0x03,0x00,0xff,0xbd,0x01,0x00,0xfa,0xe5,0xaa,0x00,0xdf,0xd4,0xb8,0x00,0xba,0xaa,0x7f,0x00,
+		0xba,0xaa,0x7f,0x00,0xb9,0xaa,0x80,0x00,0xb9,0xab,0x82,0x00,0xb7,0xaa,0x82,0x00,0xb7,0xa9,0x83,0x00,0xb6,0xa9,0x84,0x00,
+		0xb6,0xa9,0x85,0x00,0xb6,0xa9,0x86,0x00,0xb4,0xa7,0x85,0x00,0xb2,0xa5,0x84,0x00,0xaf,0xa3,0x81,0x00,0xaa,0x9e,0x7e,0x00,
+		0xa4,0x99,0x77,0x00,0x99,0x8e,0x6c,0x00,0x8e,0x82,0x61,0x00,0x80,0x75,0x53,0x00,0x72,0x66,0x44,0x00,0x64,0x58,0x35,0x00,
+		0x57,0x4a,0x26,0x00,0x4c,0x40,0x1a,0x00,0x45,0x38,0x11,0x00,0x3f,0x31,0x09,0x00,0x3d,0x2f,0x05,0x00,0x3c,0x2d,0x02,0x00,
+		0x3c,0x2d,0x01,0x00,0x3e,0x2e,0x01,0x00,0x3f,0x2e,0x00,0x00,0x41,0x2f,0x00,0x00,0x43,0x31,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x45,0x33,0x00,0x00,0x47,0x34,0x00,0x00,0x46,0x34,0x00,0x00,0x47,0x35,0x00,0x00,0x47,0x35,0x00,0x00,0x47,0x34,0x00,0x00,
+		0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x43,0x32,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,
+		0x3b,0x2b,0x00,0x00,0x38,0x29,0x00,0x00,0x37,0x28,0x00,0x00,0x34,0x27,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,
+		0x2b,0x20,0x00,0x00,0x28,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,0x1e,0x17,0x00,0x00,0x1b,0x14,0x00,0x00,
+		0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x14,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,
+		0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x02,0x04,0x00,0x05,0x03,0x06,0x00,
+		0x06,0x04,0x08,0x00,0x08,0x04,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x06,0x0d,0x00,0x0e,0x06,0x10,0x00,0x10,0x08,0x13,0x00,
+		0x13,0x09,0x16,0x00,0x16,0x0a,0x19,0x00,0x18,0x0c,0x1c,0x00,0x1c,0x0d,0x21,0x00,0x1f,0x0f,0x25,0x00,0x23,0x10,0x29,0x00,
+		0x27,0x12,0x2d,0x00,0x2b,0x14,0x32,0x00,0x2f,0x15,0x36,0x00,0x32,0x17,0x3b,0x00,0x37,0x18,0x41,0x00,0x3b,0x1a,0x44,0x00,
+		0x3f,0x1b,0x4a,0x00,0x42,0x1c,0x4d,0x00,0x46,0x1e,0x51,0x00,0x49,0x20,0x55,0x00,0x4d,0x22,0x58,0x00,0x52,0x24,0x5e,0x00,
+		0x56,0x28,0x63,0x00,0x5d,0x2d,0x6a,0x00,0x64,0x32,0x71,0x00,0x6e,0x3c,0x7b,0x00,0x79,0x45,0x86,0x00,0x83,0x4f,0x90,0x00,
+		0x8e,0x5a,0x9c,0x00,0x97,0x63,0xa4,0x00,0xa1,0x6e,0xaf,0x00,0xaa,0x76,0xb6,0x00,0xaf,0x7c,0xbb,0x00,0xb2,0x80,0xbe,0x00,
+		0xb3,0x84,0xc0,0x00,0xfb,0xf3,0xfd,0x00,0xc6,0x52,0xec,0x00,0xb9,0x2b,0xe8,0x00,0xbb,0x33,0xe8,0x00,0xba,0x33,0xe9,0x00,
+		0xba,0x33,0xe9,0x00,0xba,0x33,0xe9,0x00,0xba,0x33,0xe9,0x00,0xba,0x33,0xea,0x00,0xba,0x33,0xe9,0x00,0xba,0x33,0xeb,0x00,
+		0xbb,0x32,0xea,0x00,0xb4,0x2e,0xe7,0x00,0xa4,0x33,0xd7,0x00,0xab,0x4d,0xd7,0x00,0xcb,0x6a,0xea,0x00,0xdc,0x72,0xf5,0x00,
+		0xd8,0x6d,0xf4,0x00,0xd5,0x6a,0xf2,0x00,0xd4,0x68,0xf2,0x00,0xd2,0x66,0xf1,0x00,0xd1,0x64,0xf1,0x00,0xcf,0x62,0xf0,0x00,
+		0xcd,0x61,0xf0,0x00,0xca,0x58,0xef,0x00,0xcf,0x66,0xf0,0x00,0xff,0xe7,0xff,0x00,0xc7,0xff,0xeb,0x00,0x4f,0xed,0xc3,0x00,
+		0x52,0xed,0xc4,0x00,0x54,0xec,0xc3,0x00,0x54,0xec,0xc3,0x00,0x54,0xec,0xc2,0x00,0x52,0xeb,0xc1,0x00,0x52,0xeb,0xc0,0x00,
+		0x52,0xeb,0xbf,0x00,0x52,0xeb,0xc2,0x00,0x52,0xeb,0xbf,0x00,0x44,0xe1,0xa9,0x00,0x31,0xd7,0x8d,0x00,0x2c,0xd8,0x89,0x00,
+		0x30,0xdc,0x92,0x00,0x31,0xdc,0x94,0x00,0x33,0xdc,0x94,0x00,0x36,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x39,0xde,0x99,0x00,
+		0x3c,0xde,0x9a,0x00,0x3e,0xde,0x9c,0x00,0x40,0xdf,0x9d,0x00,0x43,0xe0,0x9e,0x00,0x39,0xde,0x9a,0x00,0x90,0xec,0xc6,0x00,
+		0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9a,0xae,0xa6,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa5,0x00,
+		0x9c,0xa8,0xa3,0x00,0x9d,0xa6,0xa3,0x00,0x9c,0xa4,0xa1,0x00,0x9c,0xa2,0xa1,0x00,0x9c,0xa1,0xa0,0x00,0xb4,0xb8,0xb7,0x00,
+		0xd6,0xd7,0xd8,0x00,0x77,0x79,0x7c,0x00,0xa5,0xa6,0xa8,0x00,0xe6,0xe7,0xe7,0x00,0xe4,0xe4,0xe5,0x00,0xce,0xcf,0xcf,0x00,
+		0xc2,0xc2,0xc3,0x00,0xb5,0xb6,0xb6,0x00,0xaa,0xaa,0xaa,0x00,0xb8,0xb8,0xb8,0x00,0xd0,0xd1,0xd1,0x00,0xe7,0xe8,0xe8,0x00,
+		0x7f,0x81,0x83,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x48,0x4a,0x4e,0x00,0x4b,0x4d,0x50,0x00,0x53,0x56,0x59,0x00,
+		0x5e,0x61,0x63,0x00,0xa1,0xa1,0xa4,0x00,0xde,0xdf,0xdf,0x00,0xce,0xce,0xce,0x00,0xce,0xce,0xcf,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x89,0x8a,0x8d,0x00,
+		0xe0,0xe0,0xe1,0x00,0xab,0xab,0xac,0x00,0x99,0x9a,0x9b,0x00,0x99,0x9a,0x9b,0x00,0x96,0x98,0x99,0x00,0x95,0x96,0x97,0x00,
+		0x95,0x95,0x96,0x00,0x93,0x94,0x95,0x00,0x92,0x93,0x94,0x00,0x92,0x93,0x94,0x00,0x93,0x93,0x94,0x00,0x93,0x94,0x95,0x00,
+		0x95,0x95,0x96,0x00,0x97,0x97,0x98,0x00,0x9a,0x9a,0x9b,0x00,0x9b,0x9c,0x9c,0x00,0x9d,0x9e,0x9e,0x00,0x9f,0x9f,0x9f,0x00,
+		0xc3,0xc3,0xc3,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf0,0xeb,0xda,0x00,0xb5,0xb2,0xac,0x00,0xae,0xab,0xa1,0x00,
+		0xbe,0xbc,0xb2,0x00,0xf5,0xf2,0xea,0x00,0xfd,0xde,0x83,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xd4,0x59,0x00,
+		0xfa,0xee,0xcd,0x00,0xf9,0xf4,0xe4,0x00,0xf5,0xef,0xde,0x00,0xee,0xe8,0xd7,0x00,0xe5,0xde,0xca,0x00,0xe1,0xda,0xc4,0x00,
+		0xea,0xe4,0xd2,0x00,0xf1,0xeb,0xd8,0x00,0xf7,0xf1,0xe2,0x00,0xfb,0xf5,0xe2,0x00,0xfc,0xea,0xb8,0x00,0xff,0xda,0x71,0x00,
+		0xff,0xc9,0x2e,0x00,0xfc,0xe5,0xa4,0x00,0xeb,0xe1,0xc8,0x00,0xc8,0xb8,0x8c,0x00,0xc8,0xb8,0x8c,0x00,0xf0,0xe7,0xd1,0x00,
+		0xfd,0xe1,0x91,0x00,0xff,0xc4,0x1a,0x00,0xff,0xc1,0x0e,0x00,0xff,0xbe,0x05,0x00,0xfe,0xbc,0x01,0x00,0xfe,0xbb,0x00,0x00,
+		0xff,0xbd,0x00,0x00,0xfb,0xe8,0xb1,0x00,0xe1,0xda,0xc4,0x00,0xc1,0xb3,0x8b,0x00,0xc0,0xb3,0x8d,0x00,0xc0,0xb3,0x8e,0x00,
+		0xc0,0xb3,0x8f,0x00,0xbf,0xb3,0x90,0x00,0xbe,0xb2,0x91,0x00,0xbe,0xb3,0x91,0x00,0xbe,0xb3,0x91,0x00,0xbe,0xb2,0x92,0x00,
+		0xbd,0xb2,0x93,0x00,0xbc,0xb2,0x93,0x00,0xb5,0xaa,0x8b,0x00,0xaa,0x9e,0x7d,0x00,0xa5,0x98,0x77,0x00,0x9b,0x8f,0x6e,0x00,
+		0x8e,0x82,0x61,0x00,0x82,0x75,0x54,0x00,0x74,0x68,0x45,0x00,0x66,0x59,0x35,0x00,0x57,0x4b,0x26,0x00,0x4e,0x41,0x1c,0x00,
+		0x46,0x39,0x12,0x00,0x3f,0x32,0x0b,0x00,0x3c,0x2e,0x05,0x00,0x3b,0x2c,0x02,0x00,0x3b,0x2c,0x01,0x00,0x3d,0x2e,0x01,0x00,
+		0x3e,0x2e,0x00,0x00,0x40,0x30,0x00,0x00,0x42,0x31,0x00,0x00,0x43,0x31,0x00,0x00,0x45,0x32,0x00,0x00,0x45,0x33,0x00,0x00,
+		0x46,0x33,0x00,0x00,0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x46,0x34,0x00,0x00,0x45,0x33,0x00,0x00,0x44,0x32,0x00,0x00,
+		0x44,0x32,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x2f,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3a,0x2b,0x00,0x00,0x38,0x29,0x00,0x00,
+		0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x30,0x23,0x00,0x00,0x2d,0x21,0x00,0x00,0x2b,0x20,0x00,0x00,0x27,0x1d,0x00,0x00,
+		0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,0x1e,0x16,0x00,0x00,0x1c,0x14,0x00,0x00,0x19,0x12,0x00,0x00,0x17,0x11,0x00,0x00,
+		0x14,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0b,0x00,0x00,0x0b,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x02,0x04,0x00,0x05,0x03,0x06,0x00,0x06,0x04,0x07,0x00,0x07,0x04,0x09,0x00,
+		0x0a,0x06,0x0b,0x00,0x0b,0x05,0x0d,0x00,0x0e,0x06,0x10,0x00,0x10,0x08,0x12,0x00,0x13,0x09,0x16,0x00,0x15,0x0a,0x19,0x00,
+		0x18,0x0c,0x1c,0x00,0x1c,0x0d,0x20,0x00,0x1f,0x0f,0x25,0x00,0x24,0x10,0x28,0x00,0x27,0x12,0x2c,0x00,0x2b,0x13,0x31,0x00,
+		0x2e,0x15,0x36,0x00,0x33,0x17,0x3b,0x00,0x36,0x19,0x40,0x00,0x3a,0x1a,0x45,0x00,0x3d,0x1b,0x47,0x00,0x41,0x1d,0x4c,0x00,
+		0x46,0x1e,0x51,0x00,0x4a,0x20,0x54,0x00,0x4d,0x22,0x5a,0x00,0x52,0x25,0x5f,0x00,0x56,0x28,0x63,0x00,0x5c,0x2d,0x6a,0x00,
+		0x66,0x35,0x73,0x00,0x6d,0x3c,0x7b,0x00,0x79,0x46,0x86,0x00,0x83,0x4f,0x90,0x00,0x8f,0x5c,0x9d,0x00,0x97,0x64,0xa5,0x00,
+		0xa2,0x6f,0xaf,0x00,0xa8,0x77,0xb6,0x00,0xaf,0x7d,0xbc,0x00,0xb3,0x82,0xc0,0x00,0xb5,0x85,0xc2,0x00,0xf8,0xf1,0xfb,0x00,
+		0xc4,0x51,0xeb,0x00,0xb7,0x2b,0xe8,0x00,0xb9,0x32,0xe7,0x00,0xb9,0x33,0xe9,0x00,0xba,0x33,0xea,0x00,0xba,0x33,0xe9,0x00,
+		0xb9,0x33,0xe9,0x00,0xb9,0x33,0xe9,0x00,0xba,0x33,0xea,0x00,0xb7,0x30,0xea,0x00,0xa7,0x30,0xdb,0x00,0xa6,0x46,0xd4,0x00,
+		0xc7,0x6a,0xe6,0x00,0xe0,0x7a,0xf5,0x00,0xe0,0x77,0xf7,0x00,0xda,0x72,0xf4,0x00,0xd9,0x70,0xf4,0x00,0xd7,0x6e,0xf2,0x00,
+		0xd6,0x6b,0xf2,0x00,0xd4,0x69,0xf2,0x00,0xd3,0x67,0xf2,0x00,0xd1,0x65,0xf0,0x00,0xd0,0x63,0xf0,0x00,0xcd,0x5b,0xf0,0x00,
+		0xd1,0x69,0xf1,0x00,0xff,0xe8,0xff,0x00,0xc7,0xff,0xeb,0x00,0x50,0xed,0xc3,0x00,0x53,0xed,0xc4,0x00,0x55,0xed,0xc5,0x00,
+		0x54,0xec,0xc4,0x00,0x54,0xec,0xc3,0x00,0x53,0xec,0xc2,0x00,0x52,0xeb,0xc1,0x00,0x52,0xeb,0xc0,0x00,0x51,0xeb,0xbf,0x00,
+		0x52,0xeb,0xc0,0x00,0x52,0xec,0xc2,0x00,0x4e,0xe9,0xbb,0x00,0x3e,0xde,0xa0,0x00,0x2e,0xd7,0x8a,0x00,0x2d,0xd9,0x8b,0x00,
+		0x31,0xdc,0x94,0x00,0x34,0xdc,0x96,0x00,0x35,0xdd,0x96,0x00,0x37,0xdd,0x97,0x00,0x39,0xde,0x99,0x00,0x3c,0xde,0x9a,0x00,
+		0x3e,0xdf,0x9c,0x00,0x41,0xe0,0x9e,0x00,0x36,0xde,0x99,0x00,0x8f,0xec,0xc5,0x00,0xf5,0xf8,0xf7,0x00,0xaa,0xbd,0xb5,0x00,
+		0x9b,0xae,0xa7,0x00,0x9b,0xad,0xa6,0x00,0x9c,0xab,0xa6,0x00,0x9d,0xa9,0xa4,0x00,0x9d,0xa8,0xa4,0x00,0x9d,0xa6,0xa3,0x00,
+		0x9c,0xa5,0xa2,0x00,0x9c,0xa3,0xa0,0x00,0x9b,0xa1,0x9f,0x00,0xb4,0xb8,0xb7,0x00,0xdb,0xdc,0xdc,0x00,0x62,0x63,0x67,0x00,
+		0x47,0x49,0x4d,0x00,0x67,0x69,0x6c,0x00,0xae,0xaf,0xb1,0x00,0xcb,0xcc,0xcd,0x00,0xd4,0xd4,0xd5,0x00,0xde,0xdf,0xdf,0x00,
+		0xe5,0xe5,0xe6,0x00,0xdf,0xe0,0xe0,0x00,0xce,0xce,0xcf,0x00,0x87,0x88,0x8b,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x48,0x4b,0x4e,0x00,0x4d,0x50,0x53,0x00,0x58,0x59,0x5d,0x00,0x60,0x62,0x65,0x00,0x62,0x64,0x68,0x00,0xb8,0xba,0xbb,0x00,
+		0xdc,0xdd,0xdd,0x00,0xc9,0xc9,0xc9,0x00,0xce,0xce,0xcf,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x89,0x8a,0x8d,0x00,0xe0,0xe1,0xe1,0x00,0xab,0xab,0xac,0x00,
+		0x99,0x99,0x9a,0x00,0x97,0x98,0x99,0x00,0x95,0x96,0x97,0x00,0x94,0x95,0x95,0x00,0x90,0x91,0x92,0x00,0x90,0x90,0x91,0x00,
+		0x8f,0x8f,0x90,0x00,0x8e,0x8e,0x8f,0x00,0x8f,0x90,0x90,0x00,0x90,0x90,0x90,0x00,0x92,0x92,0x93,0x00,0x95,0x95,0x95,0x00,
+		0x97,0x97,0x98,0x00,0x9b,0x9b,0x9b,0x00,0x9d,0x9d,0x9e,0x00,0xa0,0xa0,0xa0,0x00,0xc3,0xc3,0xc3,0x00,0xf6,0xec,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xf0,0xeb,0xda,0x00,0xb5,0xb3,0xac,0x00,0xaf,0xac,0xa2,0x00,0xb0,0xac,0xa1,0x00,0xde,0xdc,0xd7,0x00,
+		0xf9,0xf1,0xd9,0x00,0xff,0xcc,0x39,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xcb,0x35,0x00,0xff,0xd4,0x5b,0x00,
+		0xfe,0xde,0x7f,0x00,0xfd,0xe6,0xa6,0x00,0xfb,0xed,0xc6,0x00,0xfb,0xee,0xca,0x00,0xfc,0xea,0xb6,0x00,0xfe,0xe3,0x97,0x00,
+		0xff,0xdb,0x74,0x00,0xff,0xce,0x45,0x00,0xff,0xc8,0x29,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xe5,0xa6,0x00,
+		0xea,0xe1,0xc8,0x00,0xc8,0xb8,0x8d,0x00,0xc7,0xb8,0x8d,0x00,0xef,0xe6,0xd0,0x00,0xfd,0xde,0x88,0x00,0xff,0xbf,0x07,0x00,
+		0xff,0xbe,0x02,0x00,0xff,0xbd,0x00,0x00,0xfd,0xbb,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfb,0xd6,0x6e,0x00,
+		0xf6,0xee,0xd7,0x00,0xf6,0xef,0xdb,0x00,0xf4,0xec,0xd7,0x00,0xf4,0xed,0xd8,0x00,0xf4,0xed,0xd8,0x00,0xf4,0xed,0xd8,0x00,
+		0xf4,0xec,0xd8,0x00,0xf4,0xed,0xd8,0x00,0xf4,0xec,0xd8,0x00,0xf3,0xeb,0xd7,0x00,0xf4,0xed,0xd9,0x00,0xf3,0xed,0xda,0x00,
+		0xdd,0xd7,0xc9,0x00,0xab,0x9f,0x7e,0x00,0xa3,0x98,0x76,0x00,0x9c,0x90,0x6e,0x00,0x90,0x84,0x62,0x00,0x84,0x78,0x55,0x00,
+		0x75,0x68,0x46,0x00,0x66,0x5a,0x36,0x00,0x59,0x4c,0x27,0x00,0x4d,0x41,0x1b,0x00,0x44,0x38,0x12,0x00,0x3f,0x32,0x0b,0x00,
+		0x3c,0x2e,0x05,0x00,0x3c,0x2d,0x03,0x00,0x3c,0x2c,0x01,0x00,0x3d,0x2d,0x01,0x00,0x3e,0x2e,0x00,0x00,0x3f,0x2f,0x00,0x00,
+		0x41,0x30,0x00,0x00,0x42,0x30,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x33,0x00,0x00,
+		0x45,0x33,0x00,0x00,0x44,0x32,0x00,0x00,0x44,0x33,0x00,0x00,0x43,0x32,0x00,0x00,0x42,0x31,0x00,0x00,0x40,0x2f,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,0x39,0x2a,0x00,0x00,0x37,0x29,0x00,0x00,0x34,0x26,0x00,0x00,0x31,0x24,0x00,0x00,
+		0x2e,0x22,0x00,0x00,0x2d,0x21,0x00,0x00,0x2a,0x20,0x00,0x00,0x27,0x1d,0x00,0x00,0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,
+		0x1e,0x17,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x14,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,
+		0x0f,0x0b,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,
+		0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,
+		0x04,0x02,0x04,0x00,0x05,0x03,0x06,0x00,0x06,0x04,0x07,0x00,0x07,0x04,0x09,0x00,0x09,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,
+		0x0e,0x06,0x10,0x00,0x11,0x08,0x12,0x00,0x12,0x09,0x15,0x00,0x15,0x0a,0x19,0x00,0x18,0x0c,0x1c,0x00,0x1b,0x0d,0x1f,0x00,
+		0x1f,0x0f,0x25,0x00,0x23,0x11,0x28,0x00,0x27,0x12,0x2c,0x00,0x2b,0x14,0x32,0x00,0x2e,0x15,0x36,0x00,0x33,0x17,0x3b,0x00,
+		0x37,0x19,0x3f,0x00,0x3a,0x1a,0x44,0x00,0x3e,0x1c,0x48,0x00,0x41,0x1d,0x4b,0x00,0x45,0x1f,0x51,0x00,0x49,0x20,0x54,0x00,
+		0x4e,0x22,0x59,0x00,0x52,0x26,0x5f,0x00,0x57,0x28,0x63,0x00,0x5e,0x2e,0x6a,0x00,0x64,0x35,0x72,0x00,0x6f,0x3d,0x7c,0x00,
+		0x79,0x47,0x86,0x00,0x84,0x52,0x92,0x00,0x8e,0x5b,0x9c,0x00,0x99,0x65,0xa6,0x00,0xa1,0x6f,0xae,0x00,0xaa,0x78,0xb7,0x00,
+		0xae,0x7d,0xba,0x00,0xb3,0x82,0xc0,0x00,0xb5,0x86,0xc2,0x00,0xf9,0xf2,0xfc,0x00,0xc2,0x51,0xea,0x00,0xb6,0x2b,0xe6,0x00,
+		0xb7,0x32,0xe6,0x00,0xb8,0x33,0xe7,0x00,0xb8,0x33,0xe8,0x00,0xb8,0x33,0xe9,0x00,0xb9,0x33,0xe9,0x00,0xb7,0x2f,0xe8,0x00,
+		0xaa,0x2e,0xde,0x00,0xa3,0x3f,0xd4,0x00,0xbf,0x65,0xe0,0x00,0xdf,0x7f,0xf4,0x00,0xe7,0x7f,0xfa,0x00,0xe0,0x7a,0xf6,0x00,
+		0xde,0x77,0xf5,0x00,0xdc,0x75,0xf5,0x00,0xdc,0x73,0xf4,0x00,0xd9,0x71,0xf4,0x00,0xd8,0x6f,0xf3,0x00,0xd6,0x6c,0xf2,0x00,
+		0xd5,0x6a,0xf2,0x00,0xd3,0x68,0xf2,0x00,0xd2,0x67,0xf2,0x00,0xcf,0x5e,0xf0,0x00,0xd3,0x6c,0xf1,0x00,0xff,0xe8,0xff,0x00,
+		0xc7,0xff,0xec,0x00,0x51,0xed,0xc5,0x00,0x55,0xed,0xc6,0x00,0x56,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x54,0xed,0xc4,0x00,
+		0x54,0xec,0xc3,0x00,0x54,0xec,0xc3,0x00,0x54,0xeb,0xc2,0x00,0x53,0xeb,0xc1,0x00,0x53,0xec,0xc0,0x00,0x51,0xeb,0xc0,0x00,
+		0x51,0xec,0xc0,0x00,0x52,0xec,0xc2,0x00,0x4b,0xe7,0xb6,0x00,0x3a,0xdc,0x98,0x00,0x2c,0xd7,0x87,0x00,0x2e,0xd9,0x8e,0x00,
+		0x33,0xdd,0x96,0x00,0x36,0xdd,0x97,0x00,0x37,0xdd,0x97,0x00,0x3a,0xde,0x99,0x00,0x3c,0xde,0x9a,0x00,0x3f,0xdf,0x9c,0x00,
+		0x34,0xdd,0x97,0x00,0x8d,0xec,0xc4,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xae,0xa6,0x00,0x9b,0xad,0xa6,0x00,
+		0x9c,0xab,0xa5,0x00,0x9d,0xa9,0xa4,0x00,0x9d,0xa8,0xa3,0x00,0x9d,0xa6,0xa2,0x00,0x9d,0xa5,0xa2,0x00,0x9d,0xa3,0xa1,0x00,
+		0x9c,0xa1,0xa0,0x00,0xb4,0xb8,0xb7,0x00,0xda,0xdb,0xdb,0x00,0x66,0x68,0x6b,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x4c,0x4e,0x52,0x00,0x58,0x5a,0x5d,0x00,0x67,0x69,0x6c,0x00,0x72,0x75,0x77,0x00,0x66,0x68,0x6b,0x00,
+		0x50,0x53,0x55,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x49,0x4b,0x4f,0x00,0x50,0x53,0x56,0x00,0x5b,0x5e,0x61,0x00,
+		0x61,0x63,0x66,0x00,0x62,0x65,0x68,0x00,0x76,0x78,0x7a,0x00,0xe4,0xe5,0xe5,0x00,0xcb,0xcb,0xcc,0x00,0xc9,0xc9,0xc9,0x00,
+		0xce,0xce,0xcf,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x89,0x8a,0x8d,0x00,0xe0,0xe1,0xe1,0x00,0xab,0xab,0xac,0x00,0x98,0x99,0x9a,0x00,0x96,0x97,0x98,0x00,
+		0x94,0x94,0x95,0x00,0x91,0x92,0x93,0x00,0x8f,0x90,0x90,0x00,0x8b,0x8c,0x8d,0x00,0x8a,0x8a,0x8a,0x00,0x89,0x89,0x8a,0x00,
+		0x89,0x89,0x8a,0x00,0x8a,0x8a,0x8b,0x00,0x8e,0x8e,0x8f,0x00,0x90,0x91,0x92,0x00,0x95,0x95,0x96,0x00,0x9a,0x9a,0x9a,0x00,
+		0x9d,0x9d,0x9d,0x00,0xa0,0xa0,0xa0,0x00,0xc3,0xc3,0xc3,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf1,0xeb,0xdb,0x00,
+		0xb6,0xb4,0xac,0x00,0xaf,0xac,0xa3,0x00,0xb1,0xad,0xa3,0x00,0xbe,0xbb,0xb1,0x00,0xf1,0xef,0xea,0x00,0xf9,0xe7,0xb3,0x00,
+		0xff,0xc9,0x2f,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc9,0x2f,0x00,0xff,0xca,0x34,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xfc,0xe6,0xa6,0x00,0xea,0xe1,0xc9,0x00,0xc6,0xb7,0x8d,0x00,
+		0xc2,0xb3,0x86,0x00,0xed,0xe4,0xcc,0x00,0xfd,0xdc,0x81,0x00,0xff,0xbd,0x00,0x00,0xff,0xbd,0x00,0x00,0xfe,0xbc,0x00,0x00,
+		0xfe,0xbc,0x00,0x00,0xff,0xbd,0x00,0x00,0xff,0xbd,0x00,0x00,0xfe,0xbd,0x05,0x00,0xfd,0xcb,0x3e,0x00,0xfe,0xce,0x47,0x00,
+		0xff,0xce,0x45,0x00,0xff,0xcf,0x45,0x00,0xfe,0xce,0x45,0x00,0xfd,0xcc,0x44,0x00,0xfd,0xcd,0x44,0x00,0xfe,0xce,0x45,0x00,
+		0xfd,0xcd,0x44,0x00,0xfd,0xcd,0x44,0x00,0xfd,0xcc,0x40,0x00,0xfc,0xe1,0x94,0x00,0xe2,0xde,0xd2,0x00,0xac,0xa0,0x7e,0x00,
+		0xa5,0x9a,0x78,0x00,0x9c,0x91,0x6e,0x00,0x91,0x84,0x62,0x00,0x83,0x76,0x55,0x00,0x75,0x68,0x46,0x00,0x67,0x5a,0x37,0x00,
+		0x5a,0x4d,0x28,0x00,0x4f,0x42,0x1d,0x00,0x45,0x38,0x12,0x00,0x3f,0x32,0x0b,0x00,0x3b,0x2d,0x05,0x00,0x3b,0x2c,0x03,0x00,
+		0x3b,0x2b,0x01,0x00,0x3c,0x2d,0x01,0x00,0x3d,0x2d,0x00,0x00,0x3e,0x2e,0x00,0x00,0x40,0x30,0x00,0x00,0x41,0x2f,0x00,0x00,
+		0x42,0x30,0x00,0x00,0x43,0x31,0x00,0x00,0x43,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x43,0x32,0x00,0x00,0x43,0x32,0x00,0x00,
+		0x42,0x31,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x2f,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3b,0x2b,0x00,0x00,
+		0x39,0x2a,0x00,0x00,0x37,0x28,0x00,0x00,0x34,0x27,0x00,0x00,0x31,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2c,0x21,0x00,0x00,
+		0x29,0x1f,0x00,0x00,0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1b,0x13,0x00,0x00,
+		0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x14,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0c,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x01,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x02,0x04,0x00,0x04,0x03,0x06,0x00,
+		0x06,0x04,0x07,0x00,0x07,0x04,0x09,0x00,0x09,0x05,0x0b,0x00,0x0c,0x06,0x0e,0x00,0x0d,0x06,0x10,0x00,0x10,0x08,0x13,0x00,
+		0x13,0x09,0x14,0x00,0x14,0x0a,0x18,0x00,0x18,0x0c,0x1c,0x00,0x1c,0x0d,0x20,0x00,0x1f,0x0f,0x23,0x00,0x23,0x11,0x28,0x00,
+		0x27,0x12,0x2d,0x00,0x2a,0x14,0x31,0x00,0x2e,0x15,0x36,0x00,0x33,0x18,0x3a,0x00,0x37,0x19,0x3f,0x00,0x3a,0x1b,0x42,0x00,
+		0x3d,0x1c,0x47,0x00,0x42,0x1e,0x4c,0x00,0x44,0x1f,0x4f,0x00,0x4a,0x22,0x55,0x00,0x4d,0x23,0x58,0x00,0x51,0x27,0x5e,0x00,
+		0x57,0x2a,0x63,0x00,0x5d,0x2f,0x69,0x00,0x65,0x36,0x73,0x00,0x6f,0x3e,0x7c,0x00,0x78,0x47,0x85,0x00,0x82,0x51,0x90,0x00,
+		0x8e,0x5d,0x9c,0x00,0x98,0x66,0xa6,0x00,0xa1,0x6f,0xaf,0x00,0xa8,0x77,0xb6,0x00,0xb0,0x7f,0xbd,0x00,0xb1,0x83,0xbf,0x00,
+		0xb4,0x86,0xc1,0x00,0xf9,0xf2,0xfc,0x00,0xc1,0x51,0xea,0x00,0xb4,0x2b,0xe6,0x00,0xb7,0x33,0xe7,0x00,0xb7,0x33,0xe7,0x00,
+		0xb8,0x33,0xe9,0x00,0xb9,0x31,0xeb,0x00,0xad,0x2d,0xe1,0x00,0xa2,0x38,0xd4,0x00,0xb8,0x60,0xdc,0x00,0xe0,0x82,0xf2,0x00,
+		0xec,0x89,0xfc,0x00,0xe7,0x83,0xf9,0x00,0xe3,0x7f,0xf7,0x00,0xe3,0x7d,0xf7,0x00,0xe1,0x7b,0xf6,0x00,0xdf,0x78,0xf5,0x00,
+		0xdd,0x77,0xf5,0x00,0xdc,0x74,0xf4,0x00,0xdb,0x72,0xf4,0x00,0xd9,0x70,0xf3,0x00,0xd7,0x6e,0xf3,0x00,0xd6,0x6c,0xf3,0x00,
+		0xd5,0x6a,0xf2,0x00,0xd2,0x62,0xf1,0x00,0xd5,0x6f,0xf2,0x00,0xff,0xe8,0xff,0x00,0xc7,0xff,0xec,0x00,0x52,0xee,0xc7,0x00,
+		0x55,0xee,0xc7,0x00,0x56,0xed,0xc6,0x00,0x57,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xed,0xc5,0x00,0x54,0xec,0xc3,0x00,
+		0x53,0xec,0xc3,0x00,0x53,0xeb,0xc2,0x00,0x53,0xeb,0xc2,0x00,0x53,0xec,0xc0,0x00,0x51,0xeb,0xc0,0x00,0x51,0xea,0xbe,0x00,
+		0x52,0xeb,0xc1,0x00,0x53,0xec,0xc1,0x00,0x48,0xe4,0xaf,0x00,0x35,0xd9,0x91,0x00,0x2d,0xd7,0x88,0x00,0x31,0xdb,0x91,0x00,
+		0x36,0xde,0x98,0x00,0x38,0xde,0x97,0x00,0x39,0xde,0x99,0x00,0x3c,0xde,0x9b,0x00,0x32,0xdd,0x95,0x00,0x8c,0xec,0xc4,0x00,
+		0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,0x9b,0xae,0xa7,0x00,0x9c,0xad,0xa6,0x00,0x9c,0xab,0xa5,0x00,0x9c,0xa9,0xa5,0x00,
+		0x9d,0xa8,0xa4,0x00,0x9c,0xa6,0xa2,0x00,0x9c,0xa3,0xa1,0x00,0x9c,0xa2,0xa0,0x00,0x9b,0xa0,0x9f,0x00,0xb6,0xb9,0xb7,0x00,
+		0xda,0xdb,0xdb,0x00,0x65,0x67,0x6a,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,
+		0x47,0x49,0x4d,0x00,0x47,0x49,0x4c,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x49,0x4c,0x00,0x48,0x4a,0x4e,0x00,
+		0x4b,0x4e,0x50,0x00,0x54,0x56,0x5a,0x00,0x5e,0x61,0x63,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x63,0x65,0x68,0x00,
+		0xbf,0xbf,0xc1,0x00,0xeb,0xeb,0xeb,0x00,0xa6,0xa6,0xa7,0x00,0xc9,0xc9,0xc9,0x00,0xce,0xce,0xcf,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x89,0x8b,0x8d,0x00,
+		0xe0,0xe1,0xe1,0x00,0xab,0xab,0xac,0x00,0x98,0x99,0x9a,0x00,0x95,0x95,0x96,0x00,0x92,0x92,0x94,0x00,0x8e,0x8f,0x8f,0x00,
+		0x8a,0x8a,0x8b,0x00,0x86,0x87,0x88,0x00,0x84,0x84,0x85,0x00,0x82,0x82,0x83,0x00,0x83,0x83,0x84,0x00,0x84,0x85,0x85,0x00,
+		0x89,0x8a,0x8a,0x00,0x8d,0x8e,0x8e,0x00,0x92,0x93,0x93,0x00,0x97,0x98,0x98,0x00,0x9b,0x9c,0x9c,0x00,0x9f,0x9f,0x9f,0x00,
+		0xc4,0xc3,0xc3,0x00,0xf6,0xec,0xce,0x00,0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xda,0x70,0x00,0xf1,0xeb,0xdb,0x00,0xb7,0xb5,0xad,0x00,0xb0,0xad,0xa4,0x00,
+		0xb2,0xad,0xa4,0x00,0xb2,0xae,0xa3,0x00,0xc9,0xc5,0xbb,0x00,0xf5,0xf2,0xeb,0x00,0xfa,0xe5,0xa6,0x00,0xff,0xcb,0x38,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xfc,0xe6,0xa7,0x00,0xe9,0xe0,0xc6,0x00,0xbf,0xb0,0x82,0x00,0xbd,0xad,0x7e,0x00,0xec,0xe3,0xca,0x00,
+		0xfd,0xdc,0x7f,0x00,0xff,0xbc,0x00,0x00,0xff,0xbd,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,
+		0xfe,0xbb,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,
+		0xfd,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfd,0xbb,0x00,0x00,0xfd,0xbc,0x00,0x00,
+		0xfd,0xbc,0x00,0x00,0xfa,0xd8,0x78,0x00,0xe2,0xde,0xd2,0x00,0xad,0xa1,0x7e,0x00,0xa6,0x99,0x78,0x00,0x9d,0x90,0x6f,0x00,
+		0x91,0x84,0x62,0x00,0x83,0x77,0x55,0x00,0x76,0x69,0x46,0x00,0x68,0x5b,0x37,0x00,0x59,0x4c,0x28,0x00,0x4d,0x41,0x1c,0x00,
+		0x45,0x38,0x12,0x00,0x3f,0x31,0x0b,0x00,0x3b,0x2e,0x06,0x00,0x39,0x2b,0x03,0x00,0x3b,0x2c,0x02,0x00,0x3b,0x2c,0x01,0x00,
+		0x3c,0x2c,0x00,0x00,0x3d,0x2e,0x00,0x00,0x3e,0x2e,0x00,0x00,0x40,0x2f,0x00,0x00,0x41,0x2f,0x00,0x00,0x41,0x30,0x00,0x00,
+		0x42,0x30,0x00,0x00,0x42,0x30,0x00,0x00,0x41,0x30,0x00,0x00,0x41,0x30,0x00,0x00,0x41,0x30,0x00,0x00,0x40,0x30,0x00,0x00,
+		0x3e,0x2e,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,0x38,0x2a,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x32,0x25,0x00,0x00,0x30,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x28,0x1e,0x00,0x00,0x25,0x1c,0x00,0x00,
+		0x23,0x1a,0x00,0x00,0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1a,0x14,0x00,0x00,0x18,0x12,0x00,0x00,0x16,0x10,0x00,0x00,
+		0x13,0x0e,0x00,0x00,0x11,0x0c,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0c,0x0a,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x02,0x05,0x00,0x04,0x03,0x05,0x00,0x06,0x04,0x07,0x00,0x08,0x04,0x08,0x00,
+		0x09,0x05,0x0a,0x00,0x0b,0x06,0x0d,0x00,0x0d,0x06,0x0e,0x00,0x10,0x08,0x12,0x00,0x12,0x09,0x14,0x00,0x15,0x0a,0x18,0x00,
+		0x18,0x0c,0x1c,0x00,0x1b,0x0e,0x1f,0x00,0x1f,0x0f,0x23,0x00,0x22,0x11,0x28,0x00,0x26,0x13,0x2b,0x00,0x29,0x14,0x30,0x00,
+		0x2d,0x16,0x35,0x00,0x31,0x18,0x39,0x00,0x35,0x1a,0x3e,0x00,0x39,0x1b,0x43,0x00,0x3c,0x1d,0x46,0x00,0x41,0x1f,0x4b,0x00,
+		0x44,0x20,0x4e,0x00,0x49,0x22,0x55,0x00,0x4d,0x24,0x58,0x00,0x52,0x27,0x5d,0x00,0x56,0x2a,0x62,0x00,0x5d,0x30,0x68,0x00,
+		0x65,0x36,0x72,0x00,0x6d,0x3e,0x7a,0x00,0x79,0x49,0x85,0x00,0x83,0x52,0x91,0x00,0x8f,0x5e,0x9d,0x00,0x97,0x67,0xa5,0x00,
+		0xa2,0x72,0xb0,0x00,0xa8,0x79,0xb6,0x00,0xaf,0x7f,0xbd,0x00,0xb3,0x84,0xc0,0x00,0xb3,0x86,0xc1,0x00,0xf9,0xf2,0xfc,0x00,
+		0xc1,0x51,0xeb,0x00,0xb4,0x2b,0xe7,0x00,0xb7,0x33,0xe7,0x00,0xb7,0x30,0xe7,0x00,0xb0,0x2d,0xe5,0x00,0xa1,0x32,0xd6,0x00,
+		0xb0,0x56,0xd8,0x00,0xd9,0x7f,0xed,0x00,0xf1,0x90,0xfc,0x00,0xec,0x8a,0xfb,0x00,0xe8,0x86,0xf9,0x00,0xe7,0x84,0xf9,0x00,
+		0xe6,0x82,0xf8,0x00,0xe4,0x80,0xf8,0x00,0xe3,0x7e,0xf7,0x00,0xe1,0x7c,0xf7,0x00,0xe0,0x7a,0xf6,0x00,0xde,0x78,0xf5,0x00,
+		0xdd,0x75,0xf5,0x00,0xdb,0x73,0xf5,0x00,0xda,0x71,0xf5,0x00,0xd8,0x6f,0xf3,0x00,0xd7,0x6d,0xf3,0x00,0xd4,0x65,0xf2,0x00,
+		0xd7,0x72,0xf3,0x00,0xff,0xe9,0xff,0x00,0xc7,0xff,0xed,0x00,0x53,0xee,0xc8,0x00,0x57,0xee,0xc9,0x00,0x58,0xee,0xc8,0x00,
+		0x57,0xee,0xc8,0x00,0x57,0xed,0xc6,0x00,0x56,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xed,0xc4,0x00,0x54,0xec,0xc3,0x00,
+		0x54,0xec,0xc3,0x00,0x53,0xec,0xc2,0x00,0x53,0xec,0xc1,0x00,0x52,0xeb,0xc0,0x00,0x52,0xea,0xbf,0x00,0x50,0xea,0xbe,0x00,
+		0x53,0xec,0xc1,0x00,0x50,0xea,0xbe,0x00,0x43,0xe0,0xa6,0x00,0x31,0xd8,0x8c,0x00,0x2f,0xd9,0x8b,0x00,0x35,0xdd,0x95,0x00,
+		0x37,0xdd,0x98,0x00,0x3a,0xde,0x99,0x00,0x2f,0xdc,0x94,0x00,0x8a,0xeb,0xc2,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbd,0xb5,0x00,
+		0x9a,0xad,0xa6,0x00,0x9b,0xab,0xa5,0x00,0x9c,0xaa,0xa5,0x00,0x9c,0xa9,0xa4,0x00,0x9c,0xa7,0xa3,0x00,0x9c,0xa6,0xa2,0x00,
+		0x9c,0xa4,0xa1,0x00,0x9c,0xa3,0xa0,0x00,0x9c,0xa1,0x9f,0x00,0xb6,0xb9,0xb9,0x00,0xdb,0xdc,0xdd,0x00,0x66,0x69,0x6b,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,
+		0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4a,0x4e,0x00,0x4d,0x50,0x53,0x00,0x58,0x5a,0x5e,0x00,0x60,0x62,0x65,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x65,0x68,0x6a,0x00,0xaf,0xb0,0xb2,0x00,0xec,0xec,0xec,0x00,0xc0,0xc1,0xc1,0x00,
+		0x9d,0x9e,0x9f,0x00,0xcb,0xcb,0xcc,0x00,0xce,0xce,0xcf,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x89,0x8b,0x8d,0x00,0xe0,0xe1,0xe1,0x00,0xab,0xab,0xac,0x00,
+		0x97,0x97,0x98,0x00,0x94,0x95,0x95,0x00,0x90,0x90,0x91,0x00,0x8a,0x8b,0x8b,0x00,0x86,0x87,0x88,0x00,0x81,0x81,0x82,0x00,
+		0x7d,0x7e,0x7f,0x00,0x7b,0x7c,0x7d,0x00,0x7c,0x7d,0x7e,0x00,0x7f,0x7f,0x80,0x00,0x83,0x83,0x84,0x00,0x89,0x8a,0x8a,0x00,
+		0x8f,0x90,0x90,0x00,0x95,0x96,0x96,0x00,0x9b,0x9b,0x9b,0x00,0x9f,0x9f,0x9f,0x00,0xc4,0xc3,0xc3,0x00,0xf6,0xec,0xce,0x00,
+		0xff,0xcc,0x3a,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xda,0x70,0x00,0xf1,0xeb,0xdb,0x00,0xb7,0xb5,0xad,0x00,0xb0,0xad,0xa5,0x00,0xb1,0xad,0xa4,0x00,0xb2,0xae,0xa3,0x00,
+		0xb4,0xaf,0xa2,0x00,0xce,0xca,0xc1,0x00,0xf4,0xf2,0xeb,0x00,0xf9,0xee,0xce,0x00,0xff,0xd6,0x61,0x00,0xff,0xc8,0x28,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x25,0x00,0xff,0xc5,0x1d,0x00,0xfc,0xe4,0x9c,0x00,
+		0xe7,0xdf,0xc4,0x00,0xbc,0xab,0x7f,0x00,0xbc,0xab,0x7e,0x00,0xec,0xe3,0xcb,0x00,0xfd,0xdc,0x7f,0x00,0xff,0xbd,0x00,0x00,
+		0xff,0xbd,0x00,0x00,0xff,0xbd,0x00,0x00,0xff,0xbd,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfd,0xbb,0x00,0x00,
+		0xff,0xbd,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfe,0xbb,0x00,0x00,0xfe,0xbc,0x00,0x00,
+		0xfd,0xbc,0x00,0x00,0xfd,0xbb,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfc,0xbb,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfa,0xda,0x7d,0x00,
+		0xe1,0xdc,0xd1,0x00,0xac,0xa0,0x7d,0x00,0xa4,0x98,0x76,0x00,0x9d,0x91,0x6e,0x00,0x92,0x85,0x63,0x00,0x83,0x77,0x55,0x00,
+		0x75,0x69,0x46,0x00,0x66,0x5a,0x37,0x00,0x59,0x4d,0x28,0x00,0x4d,0x40,0x1c,0x00,0x43,0x37,0x12,0x00,0x3e,0x30,0x0b,0x00,
+		0x3b,0x2d,0x06,0x00,0x38,0x2a,0x03,0x00,0x39,0x2b,0x02,0x00,0x39,0x2b,0x01,0x00,0x3b,0x2b,0x00,0x00,0x3b,0x2c,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3f,0x2e,0x00,0x00,0x40,0x2f,0x00,0x00,0x3f,0x2f,0x00,0x00,0x41,0x2f,0x00,0x00,
+		0x40,0x2f,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3f,0x2f,0x00,0x00,0x3e,0x2e,0x00,0x00,0x3c,0x2d,0x00,0x00,0x3c,0x2d,0x00,0x00,
+		0x3a,0x2b,0x00,0x00,0x38,0x2a,0x00,0x00,0x36,0x28,0x00,0x00,0x34,0x26,0x00,0x00,0x32,0x25,0x00,0x00,0x2f,0x23,0x00,0x00,
+		0x2d,0x21,0x00,0x00,0x2a,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,
+		0x1c,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x0f,0x00,0x00,0x13,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x05,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,
+		0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,
+		0x04,0x03,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x06,0x00,0x08,0x05,0x08,0x00,0x09,0x05,0x0a,0x00,0x0b,0x05,0x0c,0x00,
+		0x0e,0x07,0x10,0x00,0x10,0x08,0x11,0x00,0x11,0x09,0x14,0x00,0x14,0x0a,0x17,0x00,0x17,0x0c,0x1b,0x00,0x1b,0x0e,0x1f,0x00,
+		0x1e,0x0f,0x23,0x00,0x22,0x11,0x28,0x00,0x26,0x13,0x2b,0x00,0x2a,0x15,0x2f,0x00,0x2e,0x16,0x34,0x00,0x31,0x18,0x39,0x00,
+		0x35,0x1a,0x3d,0x00,0x3a,0x1c,0x41,0x00,0x3c,0x1d,0x45,0x00,0x41,0x1f,0x4a,0x00,0x42,0x1f,0x4d,0x00,0x47,0x22,0x52,0x00,
+		0x4d,0x24,0x57,0x00,0x51,0x28,0x5c,0x00,0x55,0x2b,0x60,0x00,0x5c,0x2f,0x68,0x00,0x66,0x38,0x71,0x00,0x6e,0x40,0x7b,0x00,
+		0x7a,0x4a,0x86,0x00,0x84,0x55,0x92,0x00,0x90,0x5f,0x9d,0x00,0x98,0x68,0xa5,0x00,0xa3,0x73,0xb0,0x00,0xab,0x7b,0xb8,0x00,
+		0xae,0x80,0xbc,0x00,0xb4,0x85,0xc1,0x00,0xb5,0x88,0xc3,0x00,0xf8,0xf1,0xfb,0x00,0xbf,0x51,0xe7,0x00,0xb5,0x2a,0xe7,0x00,
+		0xb3,0x2e,0xe7,0x00,0xa3,0x2e,0xd9,0x00,0xa8,0x4b,0xd5,0x00,0xd4,0x7d,0xe9,0x00,0xf3,0x96,0xfc,0x00,0xf3,0x93,0xfe,0x00,
+		0xee,0x8d,0xfc,0x00,0xeb,0x8a,0xf9,0x00,0xeb,0x89,0xf9,0x00,0xea,0x87,0xf9,0x00,0xe8,0x85,0xf9,0x00,0xe6,0x83,0xf8,0x00,
+		0xe6,0x81,0xf8,0x00,0xe3,0x7f,0xf7,0x00,0xe2,0x7d,0xf7,0x00,0xe1,0x7b,0xf6,0x00,0xe0,0x79,0xf6,0x00,0xde,0x77,0xf5,0x00,
+		0xdd,0x74,0xf5,0x00,0xdb,0x72,0xf4,0x00,0xd9,0x70,0xf4,0x00,0xd6,0x69,0xf2,0x00,0xd8,0x75,0xf3,0x00,0xff,0xe9,0xff,0x00,
+		0xc7,0xff,0xee,0x00,0x53,0xee,0xc9,0x00,0x57,0xee,0xca,0x00,0x58,0xee,0xc9,0x00,0x58,0xee,0xc9,0x00,0x57,0xee,0xc7,0x00,
+		0x57,0xed,0xc7,0x00,0x56,0xed,0xc6,0x00,0x56,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xec,0xc4,0x00,0x54,0xec,0xc3,0x00,
+		0x54,0xec,0xc3,0x00,0x53,0xeb,0xc1,0x00,0x53,0xec,0xc1,0x00,0x51,0xea,0xbf,0x00,0x51,0xea,0xbf,0x00,0x50,0xea,0xbf,0x00,
+		0x52,0xec,0xc1,0x00,0x4e,0xe8,0xba,0x00,0x3c,0xde,0x9f,0x00,0x30,0xd7,0x8a,0x00,0x32,0xd9,0x8e,0x00,0x38,0xdd,0x98,0x00,
+		0x2d,0xdc,0x93,0x00,0x89,0xeb,0xc2,0x00,0xf5,0xf8,0xf7,0x00,0xab,0xbc,0xb5,0x00,0x9a,0xad,0xa6,0x00,0x9b,0xac,0xa5,0x00,
+		0x9c,0xaa,0xa5,0x00,0x9b,0xa7,0xa3,0x00,0x9b,0xa5,0xa1,0x00,0x9b,0xa4,0xa0,0x00,0x9b,0xa2,0xa0,0x00,0x9b,0xa1,0x9f,0x00,
+		0x9a,0x9f,0x9e,0x00,0xb1,0xb4,0xb3,0x00,0xe9,0xea,0xea,0x00,0xd9,0xda,0xda,0x00,0xa1,0xa3,0xa5,0x00,0x6e,0x70,0x73,0x00,
+		0x50,0x52,0x56,0x00,0x47,0x49,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x4a,0x4d,0x00,0x47,0x49,0x4d,0x00,0x48,0x4b,0x4e,0x00,
+		0x50,0x52,0x56,0x00,0x5b,0x5d,0x61,0x00,0x62,0x63,0x67,0x00,0x63,0x65,0x68,0x00,0x6e,0x70,0x73,0x00,0x83,0x84,0x86,0x00,
+		0xc9,0xc9,0xca,0x00,0xec,0xec,0xed,0x00,0xc4,0xc5,0xc5,0x00,0x9d,0x9e,0x9f,0x00,0x9d,0x9e,0x9f,0x00,0xcc,0xcd,0xcd,0x00,
+		0xce,0xce,0xcf,0x00,0x62,0x64,0x68,0x00,0x62,0x65,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,0x62,0x64,0x68,0x00,
+		0x62,0x64,0x68,0x00,0x84,0x86,0x89,0x00,0xe0,0xe1,0xe1,0x00,0xaa,0xab,0xac,0x00,0x96,0x97,0x98,0x00,0x92,0x93,0x94,0x00,
+		0x8e,0x8e,0x8f,0x00,0x87,0x88,0x89,0x00,0x80,0x81,0x82,0x00,0x7b,0x7b,0x7c,0x00,0x77,0x77,0x78,0x00,0x74,0x75,0x76,0x00,
+		0x75,0x75,0x76,0x00,0x79,0x79,0x79,0x00,0x7d,0x7e,0x7f,0x00,0x84,0x84,0x84,0x00,0x8b,0x8c,0x8c,0x00,0x93,0x93,0x94,0x00,
+		0x98,0x98,0x98,0x00,0x9e,0x9e,0x9e,0x00,0xc3,0xc3,0xc2,0x00,0xf7,0xec,0xce,0x00,0xff,0xc9,0x31,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xd8,0x6b,0x00,0xf1,0xeb,0xdb,0x00,
+		0xb7,0xb5,0xae,0x00,0xb0,0xae,0xa6,0x00,0xb1,0xad,0xa4,0x00,0xb2,0xae,0xa3,0x00,0xb3,0xaf,0xa3,0x00,0xb4,0xb0,0xa1,0x00,
+		0xc5,0xc0,0xb4,0x00,0xe9,0xe6,0xe0,0x00,0xf8,0xf4,0xe7,0x00,0xfa,0xeb,0xbe,0x00,0xff,0xd9,0x6c,0x00,0xff,0xcd,0x3c,0x00,
+		0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x26,0x00,
+		0xff,0xc7,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc6,0x26,0x00,0xff,0xc7,0x26,0x00,0xff,0xc7,0x28,0x00,
+		0xff,0xcd,0x3e,0x00,0xff,0xd7,0x65,0x00,0xfb,0xe7,0xac,0x00,0xf9,0xf2,0xdf,0x00,0xe0,0xd8,0xbf,0x00,0xba,0xab,0x7f,0x00,
+		0xba,0xab,0x7f,0x00,0xec,0xe4,0xcd,0x00,0xfd,0xda,0x7a,0x00,0xff,0xbd,0x00,0x00,0xff,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,
+		0xff,0xbd,0x00,0x00,0xff,0xbd,0x00,0x00,0xfe,0xbc,0x00,0x00,0xff,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,
+		0xfd,0xbc,0x00,0x00,0xff,0xbd,0x00,0x00,0xfd,0xbb,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfe,0xbc,0x00,0x00,0xfe,0xbb,0x00,0x00,
+		0xfd,0xbc,0x00,0x00,0xfd,0xbc,0x00,0x00,0xfc,0xba,0x00,0x00,0xfa,0xd8,0x77,0x00,0xe2,0xde,0xd1,0x00,0xac,0x9f,0x7d,0x00,
+		0xa5,0x99,0x76,0x00,0x9b,0x8f,0x6e,0x00,0x8f,0x82,0x61,0x00,0x83,0x76,0x55,0x00,0x75,0x69,0x46,0x00,0x65,0x59,0x36,0x00,
+		0x57,0x4b,0x28,0x00,0x4b,0x40,0x1b,0x00,0x43,0x37,0x12,0x00,0x3c,0x30,0x0b,0x00,0x39,0x2b,0x06,0x00,0x38,0x2a,0x03,0x00,
+		0x36,0x29,0x01,0x00,0x38,0x2a,0x01,0x00,0x38,0x2a,0x00,0x00,0x39,0x2b,0x00,0x00,0x3b,0x2c,0x00,0x00,0x3c,0x2d,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3e,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,
+		0x3d,0x2d,0x00,0x00,0x3d,0x2d,0x00,0x00,0x3b,0x2c,0x00,0x00,0x3a,0x2b,0x00,0x00,0x38,0x2a,0x00,0x00,0x37,0x29,0x00,0x00,
+		0x35,0x27,0x00,0x00,0x32,0x25,0x00,0x00,0x30,0x24,0x00,0x00,0x2e,0x22,0x00,0x00,0x2c,0x21,0x00,0x00,0x29,0x1e,0x00,0x00,
+		0x26,0x1c,0x00,0x00,0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,0x1e,0x17,0x00,0x00,0x1c,0x14,0x00,0x00,0x19,0x13,0x00,0x00,
+		0x17,0x11,0x00,0x00,0x15,0x0f,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,
+		0x0a,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x03,0x04,0x00,0x04,0x03,0x05,0x00,
+		0x05,0x04,0x06,0x00,0x07,0x04,0x08,0x00,0x09,0x05,0x0a,0x00,0x0b,0x05,0x0d,0x00,0x0d,0x07,0x0f,0x00,0x0f,0x08,0x11,0x00,
+		0x11,0x09,0x14,0x00,0x14,0x0a,0x17,0x00,0x17,0x0c,0x1a,0x00,0x1a,0x0e,0x1e,0x00,0x1d,0x0f,0x22,0x00,0x22,0x11,0x25,0x00,
+		0x25,0x13,0x2a,0x00,0x29,0x15,0x2e,0x00,0x2c,0x16,0x33,0x00,0x30,0x18,0x38,0x00,0x35,0x1a,0x3c,0x00,0x38,0x1b,0x3f,0x00,
+		0x3d,0x1d,0x45,0x00,0x3f,0x1e,0x48,0x00,0x43,0x21,0x4d,0x00,0x48,0x23,0x52,0x00,0x4b,0x25,0x56,0x00,0x50,0x29,0x5c,0x00,
+		0x55,0x2a,0x60,0x00,0x5b,0x31,0x67,0x00,0x64,0x38,0x70,0x00,0x6c,0x40,0x79,0x00,0x77,0x49,0x84,0x00,0x84,0x55,0x91,0x00,
+		0x8f,0x60,0x9c,0x00,0x98,0x6a,0xa6,0x00,0xa3,0x74,0xb1,0x00,0xa9,0x7b,0xb5,0x00,0xae,0x80,0xba,0x00,0xb3,0x86,0xc0,0x00,
+		0xb6,0x8a,0xc3,0x00,0xf7,0xf0,0xfa,0x00,0xc0,0x4c,0xec,0x00,0xa3,0x23,0xdd,0x00,0xa2,0x41,0xd3,0x00,0xc8,0x72,0xe0,0x00,
+		0xf3,0x9a,0xfa,0x00,0xf9,0x9b,0xfe,0x00,0xf3,0x95,0xfc,0x00,0xf1,0x93,0xfc,0x00,0xf0,0x91,0xfc,0x00,0xed,0x8d,0xfb,0x00,
+		0xed,0x8c,0xfb,0x00,0xeb,0x89,0xf9,0x00,0xea,0x88,0xfa,0x00,0xe9,0x86,0xf9,0x00,0xe8,0x84,0xf9,0x00,0xe5,0x82,0xf8,0x00,
+		0xe4,0x80,0xf8,0x00,0xe3,0x7e,0xf7,0x00,0xe2,0x7c,0xf7,0x00,0xe0,0x7a,0xf6,0x00,0xdf,0x77,0xf5,0x00,0xdd,0x76,0xf5,0x00,
+		0xdb,0x73,0xf4,0x00,0xd8,0x6c,0xf4,0x00,0xdb,0x78,0xf4,0x00,0xff,0xea,0xff,0x00,0xc7,0xff,0xee,0x00,0x55,0xef,0xca,0x00,
+		0x58,0xef,0xcb,0x00,0x59,0xef,0xca,0x00,0x59,0xee,0xca,0x00,0x59,0xee,0xc9,0x00,0x58,0xee,0xc9,0x00,0x57,0xee,0xc8,0x00,
+		0x57,0xee,0xc7,0x00,0x57,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xed,0xc4,0x00,0x54,0xec,0xc4,0x00,0x53,0xec,0xc3,0x00,
+		0x54,0xeb,0xc2,0x00,0x53,0xeb,0xc1,0x00,0x53,0xeb,0xc0,0x00,0x51,0xeb,0xc0,0x00,0x51,0xeb,0xbf,0x00,0x51,0xeb,0xbf,0x00,
+		0x52,0xeb,0xc1,0x00,0x4b,0xe6,0xb5,0x00,0x39,0xdb,0x97,0x00,0x31,0xd7,0x8a,0x00,0x25,0xd9,0x8b,0x00,0x83,0xea,0xbe,0x00,
+		0xf5,0xf8,0xf7,0x00,0xab,0xbc,0xb5,0x00,0x9a,0xac,0xa5,0x00,0x9a,0xaa,0xa4,0x00,0x9b,0xa8,0xa3,0x00,0x99,0xa5,0xa1,0x00,
+		0x9a,0xa3,0xa0,0x00,0x99,0xa1,0x9e,0x00,0x99,0xa0,0x9d,0x00,0x98,0x9e,0x9c,0x00,0x98,0x9d,0x9b,0x00,0x9c,0xa0,0x9f,0x00,
+		0xb3,0xb5,0xb5,0x00,0xcf,0xd0,0xd0,0x00,0xe6,0xe7,0xe7,0x00,0xe7,0xe8,0xe8,0x00,0xcd,0xcd,0xce,0x00,0xae,0xaf,0xb1,0x00,
+		0x8e,0x90,0x92,0x00,0x74,0x75,0x78,0x00,0x6c,0x6e,0x71,0x00,0x74,0x77,0x79,0x00,0x8a,0x8b,0x8d,0x00,0x9f,0xa1,0xa3,0x00,
+		0xb8,0xb8,0xb9,0x00,0xcb,0xcc,0xcd,0x00,0xd7,0xd8,0xd9,0x00,0xe9,0xe9,0xea,0x00,0xe5,0xe5,0xe5,0x00,0xbb,0xbc,0xbc,0x00,
+		0x9e,0x9f,0xa0,0x00,0x9e,0x9f,0xa0,0x00,0x9e,0x9e,0x9f,0x00,0xcc,0xcd,0xcd,0x00,0xdc,0xdd,0xde,0x00,0xa4,0xa6,0xa7,0x00,
+		0xa6,0xa6,0xa8,0x00,0xa6,0xa6,0xa8,0x00,0xa6,0xa6,0xa8,0x00,0xa6,0xa6,0xa8,0x00,0xa6,0xa6,0xa8,0x00,0xb3,0xb5,0xb6,0x00,
+		0xe3,0xe3,0xe4,0x00,0xab,0xab,0xac,0x00,0x95,0x95,0x96,0x00,0x90,0x91,0x91,0x00,0x8a,0x8a,0x8b,0x00,0x84,0x84,0x84,0x00,
+		0x7c,0x7c,0x7d,0x00,0x76,0x76,0x76,0x00,0x70,0x71,0x72,0x00,0x6d,0x6e,0x6f,0x00,0x6e,0x6e,0x6f,0x00,0x71,0x72,0x73,0x00,
+		0x78,0x78,0x79,0x00,0x7f,0x7f,0x80,0x00,0x87,0x87,0x88,0x00,0x90,0x90,0x90,0x00,0x97,0x97,0x97,0x00,0x9c,0x9c,0x9c,0x00,
+		0xc3,0xc3,0xc2,0x00,0xf8,0xf1,0xd9,0x00,0xff,0xe0,0x88,0x00,0xff,0xdf,0x83,0x00,0xff,0xdf,0x83,0x00,0xff,0xdf,0x83,0x00,
+		0xff,0xdf,0x83,0x00,0xff,0xdf,0x83,0x00,0xff,0xe7,0xa3,0x00,0xf1,0xec,0xde,0x00,0xb7,0xb5,0xaf,0x00,0xaf,0xac,0xa4,0x00,
+		0xaf,0xac,0xa3,0x00,0xb0,0xac,0xa1,0x00,0xb1,0xac,0xa1,0x00,0xb2,0xad,0xa1,0x00,0xb3,0xae,0x9f,0x00,0xb8,0xb2,0xa3,0x00,
+		0xce,0xca,0xbe,0x00,0xe9,0xe5,0xdc,0x00,0xf7,0xf3,0xe8,0x00,0xf9,0xef,0xd2,0x00,0xfc,0xe6,0xa8,0x00,0xff,0xda,0x70,0x00,
+		0xff,0xd2,0x51,0x00,0xff,0xd1,0x51,0x00,0xff,0xd2,0x51,0x00,0xff,0xd2,0x51,0x00,0xff,0xd1,0x51,0x00,0xff,0xd2,0x51,0x00,
+		0xff,0xd1,0x4f,0x00,0xff,0xd5,0x5d,0x00,0xfe,0xdf,0x87,0x00,0xfb,0xe9,0xb6,0x00,0xf9,0xf0,0xd5,0x00,0xf7,0xf2,0xe4,0x00,
+		0xe9,0xe3,0xd2,0x00,0xd3,0xca,0xb1,0x00,0xc1,0xb3,0x8f,0x00,0xb8,0xa9,0x80,0x00,0xb8,0xa9,0x80,0x00,0xec,0xe4,0xcd,0x00,
+		0xfe,0xe9,0xad,0x00,0xff,0xd8,0x6a,0x00,0xff,0xd9,0x6d,0x00,0xff,0xd9,0x6d,0x00,0xff,0xd9,0x6d,0x00,0xff,0xd9,0x6d,0x00,
+		0xff,0xd9,0x6d,0x00,0xfe,0xd8,0x6d,0x00,0xff,0xd9,0x6d,0x00,0xff,0xd9,0x6d,0x00,0xfd,0xd7,0x6c,0x00,0xfe,0xd8,0x6d,0x00,
+		0xfd,0xd7,0x6c,0x00,0xfd,0xd7,0x6c,0x00,0xfd,0xd7,0x6c,0x00,0xfd,0xd7,0x6c,0x00,0xfd,0xd7,0x6c,0x00,0xfd,0xd7,0x6c,0x00,
+		0xfd,0xd7,0x6a,0x00,0xfa,0xe4,0xa6,0x00,0xe2,0xde,0xd3,0x00,0xaa,0x9e,0x7b,0x00,0xa1,0x96,0x74,0x00,0x98,0x8c,0x6b,0x00,
+		0x8e,0x82,0x60,0x00,0x7f,0x73,0x52,0x00,0x71,0x65,0x44,0x00,0x63,0x58,0x35,0x00,0x56,0x4a,0x27,0x00,0x4b,0x3e,0x1b,0x00,
+		0x42,0x35,0x12,0x00,0x3b,0x2f,0x0a,0x00,0x38,0x2a,0x06,0x00,0x35,0x28,0x02,0x00,0x35,0x28,0x01,0x00,0x37,0x29,0x01,0x00,
+		0x36,0x28,0x00,0x00,0x37,0x29,0x00,0x00,0x39,0x2a,0x00,0x00,0x3a,0x2b,0x00,0x00,0x3b,0x2b,0x00,0x00,0x3b,0x2b,0x00,0x00,
+		0x3c,0x2c,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3c,0x2c,0x00,0x00,0x3c,0x2d,0x00,0x00,0x3a,0x2b,0x00,0x00,0x3a,0x2b,0x00,0x00,
+		0x39,0x2a,0x00,0x00,0x38,0x2a,0x00,0x00,0x36,0x28,0x00,0x00,0x35,0x27,0x00,0x00,0x33,0x26,0x00,0x00,0x31,0x25,0x00,0x00,
+		0x2f,0x23,0x00,0x00,0x2d,0x22,0x00,0x00,0x2a,0x1f,0x00,0x00,0x28,0x1e,0x00,0x00,0x25,0x1c,0x00,0x00,0x22,0x1a,0x00,0x00,
+		0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x14,0x0e,0x00,0x00,
+		0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x03,0x04,0x00,0x05,0x03,0x05,0x00,0x05,0x04,0x06,0x00,0x07,0x04,0x08,0x00,
+		0x08,0x05,0x0a,0x00,0x0a,0x05,0x0c,0x00,0x0c,0x06,0x0e,0x00,0x0f,0x08,0x11,0x00,0x11,0x09,0x13,0x00,0x13,0x0a,0x16,0x00,
+		0x16,0x0c,0x19,0x00,0x19,0x0e,0x1d,0x00,0x1d,0x0f,0x20,0x00,0x21,0x11,0x25,0x00,0x23,0x13,0x28,0x00,0x28,0x15,0x2d,0x00,
+		0x2b,0x16,0x31,0x00,0x2f,0x19,0x37,0x00,0x33,0x1a,0x3b,0x00,0x37,0x1c,0x3f,0x00,0x3b,0x1e,0x44,0x00,0x3f,0x20,0x48,0x00,
+		0x42,0x21,0x4c,0x00,0x47,0x24,0x51,0x00,0x4a,0x25,0x55,0x00,0x50,0x29,0x5a,0x00,0x55,0x2d,0x60,0x00,0x5b,0x32,0x66,0x00,
+		0x64,0x39,0x6f,0x00,0x6c,0x41,0x78,0x00,0x77,0x4a,0x82,0x00,0x83,0x55,0x8f,0x00,0x8f,0x60,0x9b,0x00,0x99,0x6b,0xa5,0x00,
+		0xa3,0x75,0xb0,0x00,0xaa,0x7d,0xb7,0x00,0xb0,0x82,0xbd,0x00,0xb2,0x86,0xbf,0x00,0xb6,0x8b,0xc4,0x00,0xf9,0xf2,0xfc,0x00,
+		0xae,0x55,0xd9,0x00,0xb9,0x5c,0xda,0x00,0xef,0x9a,0xf5,0x00,0xfc,0xa3,0xfc,0x00,0xf9,0x9d,0xfe,0x00,0xf6,0x99,0xfe,0x00,
+		0xf4,0x98,0xfd,0x00,0xf4,0x96,0xfd,0x00,0xf2,0x94,0xfc,0x00,0xf1,0x92,0xfc,0x00,0xef,0x8f,0xfb,0x00,0xee,0x8e,0xfb,0x00,
+		0xed,0x8c,0xfa,0x00,0xeb,0x8a,0xfa,0x00,0xea,0x87,0xfa,0x00,0xe8,0x85,0xf9,0x00,0xe7,0x84,0xf9,0x00,0xe6,0x81,0xf8,0x00,
+		0xe4,0x80,0xf7,0x00,0xe2,0x7d,0xf7,0x00,0xe1,0x7b,0xf6,0x00,0xdf,0x78,0xf5,0x00,0xde,0x78,0xf5,0x00,0xdb,0x70,0xf5,0x00,
+		0xde,0x7b,0xf5,0x00,0xff,0xea,0xff,0x00,0xc7,0xff,0xee,0x00,0x55,0xef,0xcb,0x00,0x5a,0xf0,0xcd,0x00,0x5a,0xef,0xcc,0x00,
+		0x59,0xef,0xcb,0x00,0x59,0xef,0xca,0x00,0x59,0xee,0xca,0x00,0x58,0xed,0xc9,0x00,0x58,0xee,0xc8,0x00,0x57,0xed,0xc7,0x00,
+		0x57,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xed,0xc5,0x00,0x54,0xec,0xc4,0x00,0x54,0xec,0xc3,0x00,0x54,0xeb,0xc2,0x00,
+		0x53,0xeb,0xc1,0x00,0x53,0xec,0xc1,0x00,0x52,0xeb,0xc0,0x00,0x51,0xea,0xbf,0x00,0x51,0xeb,0xbe,0x00,0x52,0xeb,0xc1,0x00,
+		0x52,0xeb,0xc0,0x00,0x3f,0xe2,0xaa,0x00,0x26,0xd6,0x89,0x00,0x97,0xeb,0xc4,0x00,0xf7,0xf9,0xf8,0x00,0xab,0xbb,0xb5,0x00,
+		0x9a,0xab,0xa4,0x00,0x99,0xa9,0xa3,0x00,0x98,0xa6,0xa1,0x00,0x97,0xa2,0x9e,0x00,0x96,0xa0,0x9d,0x00,0x95,0x9e,0x9b,0x00,
+		0x94,0x9b,0x99,0x00,0x94,0x9a,0x98,0x00,0x94,0x99,0x97,0x00,0x94,0x98,0x97,0x00,0x95,0x98,0x97,0x00,0x95,0x97,0x97,0x00,
+		0x9e,0xa0,0xa0,0x00,0xb8,0xb9,0xb9,0x00,0xd0,0xd0,0xd0,0x00,0xdd,0xdd,0xdd,0x00,0xe1,0xe1,0xe1,0x00,0xe1,0xe2,0xe2,0x00,
+		0xe0,0xe1,0xe1,0x00,0xe2,0xe3,0xe3,0x00,0xe5,0xe5,0xe5,0x00,0xe3,0xe4,0xe4,0x00,0xe0,0xe0,0xe1,0x00,0xd8,0xd8,0xd8,0x00,
+		0xca,0xcb,0xcb,0x00,0xbd,0xbd,0xbe,0x00,0xa6,0xa6,0xa7,0x00,0x9d,0x9e,0x9e,0x00,0x9d,0x9d,0x9e,0x00,0x9c,0x9d,0x9e,0x00,
+		0x9c,0x9d,0x9d,0x00,0xc1,0xc1,0xc2,0x00,0xdc,0xdc,0xdd,0x00,0xdd,0xde,0xde,0x00,0xdd,0xde,0xde,0x00,0xde,0xde,0xde,0x00,
+		0xdd,0xde,0xde,0x00,0xdd,0xde,0xde,0x00,0xdd,0xdd,0xde,0x00,0xdb,0xdb,0xdc,0x00,0xd7,0xd7,0xd7,0x00,0xa3,0xa4,0xa5,0x00,
+		0x92,0x93,0x94,0x00,0x8d,0x8e,0x8f,0x00,0x86,0x87,0x88,0x00,0x7e,0x7f,0x7f,0x00,0x76,0x77,0x77,0x00,0x6f,0x6f,0x70,0x00,
+		0x69,0x69,0x6a,0x00,0x67,0x67,0x68,0x00,0x67,0x68,0x68,0x00,0x6b,0x6b,0x6c,0x00,0x71,0x71,0x72,0x00,0x79,0x79,0x7a,0x00,
+		0x83,0x83,0x84,0x00,0x8c,0x8c,0x8c,0x00,0x94,0x94,0x94,0x00,0x9a,0x9a,0x9a,0x00,0xb8,0xb8,0xb8,0x00,0xe6,0xe3,0xda,0x00,
+		0xeb,0xe6,0xda,0x00,0xeb,0xe7,0xdb,0x00,0xeb,0xe7,0xdb,0x00,0xeb,0xe7,0xdb,0x00,0xeb,0xe7,0xdb,0x00,0xec,0xe8,0xdb,0x00,
+		0xeb,0xe6,0xd9,0x00,0xdf,0xdc,0xd5,0x00,0xb2,0xb0,0xab,0x00,0xac,0xaa,0xa2,0x00,0xad,0xaa,0xa1,0x00,0xae,0xab,0xa1,0x00,
+		0xae,0xab,0x9f,0x00,0xaf,0xab,0x9e,0x00,0xb1,0xac,0x9d,0x00,0xb2,0xac,0x9d,0x00,0xb3,0xad,0x9b,0x00,0xb7,0xb0,0x9e,0x00,
+		0xc8,0xc2,0xb2,0x00,0xdb,0xd8,0xcd,0x00,0xed,0xea,0xdf,0x00,0xf6,0xf0,0xe1,0x00,0xf7,0xf1,0xdb,0x00,0xf7,0xf0,0xda,0x00,
+		0xf7,0xf0,0xda,0x00,0xf7,0xf0,0xda,0x00,0xf7,0xf0,0xda,0x00,0xf8,0xf0,0xda,0x00,0xf8,0xf0,0xda,0x00,0xf7,0xf0,0xdd,0x00,
+		0xf2,0xec,0xde,0x00,0xe6,0xe1,0xd0,0x00,0xd4,0xcc,0xb7,0x00,0xc2,0xb7,0x97,0x00,0xb6,0xa9,0x83,0x00,0xb4,0xa6,0x80,0x00,
+		0xb5,0xa7,0x80,0x00,0xb5,0xa7,0x80,0x00,0xb5,0xa6,0x80,0x00,0xdb,0xd3,0xbc,0x00,0xed,0xe5,0xce,0x00,0xee,0xe6,0xd0,0x00,
+		0xee,0xe6,0xd0,0x00,0xed,0xe5,0xcf,0x00,0xee,0xe6,0xd0,0x00,0xee,0xe6,0xd0,0x00,0xec,0xe4,0xce,0x00,0xed,0xe5,0xcf,0x00,
+		0xee,0xe6,0xd0,0x00,0xed,0xe5,0xcf,0x00,0xed,0xe5,0xcf,0x00,0xed,0xe5,0xcf,0x00,0xed,0xe5,0xcf,0x00,0xec,0xe4,0xce,0x00,
+		0xec,0xe4,0xce,0x00,0xec,0xe4,0xce,0x00,0xed,0xe5,0xcf,0x00,0xec,0xe4,0xce,0x00,0xeb,0xe4,0xce,0x00,0xea,0xe2,0xcc,0x00,
+		0xd4,0xce,0xbe,0x00,0xa5,0x99,0x78,0x00,0x9f,0x93,0x73,0x00,0x95,0x89,0x68,0x00,0x8a,0x7e,0x5e,0x00,0x7c,0x70,0x4f,0x00,
+		0x6e,0x62,0x42,0x00,0x60,0x54,0x33,0x00,0x53,0x48,0x26,0x00,0x49,0x3d,0x1b,0x00,0x40,0x34,0x11,0x00,0x3a,0x2d,0x0a,0x00,
+		0x37,0x2a,0x06,0x00,0x33,0x27,0x02,0x00,0x34,0x26,0x01,0x00,0x35,0x27,0x01,0x00,0x35,0x27,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x36,0x28,0x00,0x00,0x37,0x29,0x00,0x00,0x38,0x29,0x00,0x00,0x39,0x2a,0x00,0x00,0x39,0x29,0x00,0x00,0x39,0x2a,0x00,0x00,
+		0x3a,0x2a,0x00,0x00,0x39,0x2a,0x00,0x00,0x39,0x2a,0x00,0x00,0x37,0x29,0x00,0x00,0x36,0x28,0x00,0x00,0x35,0x27,0x00,0x00,
+		0x35,0x26,0x00,0x00,0x33,0x26,0x00,0x00,0x31,0x25,0x00,0x00,0x2f,0x23,0x00,0x00,0x2d,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,
+		0x28,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x24,0x1b,0x00,0x00,0x21,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x19,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,
+		0x0d,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,
+		0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,
+		0x04,0x03,0x04,0x00,0x04,0x03,0x05,0x00,0x05,0x04,0x06,0x00,0x07,0x05,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x05,0x0b,0x00,
+		0x0c,0x07,0x0d,0x00,0x0e,0x08,0x10,0x00,0x11,0x09,0x13,0x00,0x13,0x0a,0x16,0x00,0x15,0x0c,0x19,0x00,0x19,0x0e,0x1c,0x00,
+		0x1c,0x0f,0x1f,0x00,0x20,0x11,0x24,0x00,0x24,0x13,0x28,0x00,0x27,0x15,0x2c,0x00,0x2a,0x16,0x30,0x00,0x2e,0x18,0x35,0x00,
+		0x33,0x1a,0x38,0x00,0x37,0x1c,0x3e,0x00,0x3a,0x1d,0x41,0x00,0x3e,0x20,0x47,0x00,0x41,0x21,0x49,0x00,0x45,0x24,0x4f,0x00,
+		0x49,0x26,0x53,0x00,0x4e,0x29,0x59,0x00,0x53,0x2d,0x5e,0x00,0x5a,0x32,0x65,0x00,0x62,0x38,0x6c,0x00,0x6b,0x41,0x77,0x00,
+		0x76,0x4b,0x81,0x00,0x81,0x56,0x8d,0x00,0x8c,0x60,0x98,0x00,0x98,0x6c,0xa5,0x00,0xa0,0x73,0xac,0x00,0xa9,0x7d,0xb4,0x00,
+		0xaf,0x83,0xbc,0x00,0xb2,0x87,0xbe,0x00,0xb6,0x8b,0xc3,0x00,0xf9,0xf9,0xfa,0x00,0xe9,0xd3,0xf1,0x00,0xfe,0xb6,0xfe,0x00,
+		0xfe,0x9f,0xfe,0x00,0xfb,0x9d,0xfe,0x00,0xf9,0x9e,0xfe,0x00,0xf6,0x9c,0xfd,0x00,0xf8,0x9c,0xff,0x00,0xf5,0x98,0xfd,0x00,
+		0xf4,0x97,0xfd,0x00,0xf3,0x95,0xfd,0x00,0xf1,0x93,0xfc,0x00,0xf0,0x90,0xfb,0x00,0xef,0x8f,0xfb,0x00,0xed,0x8d,0xfb,0x00,
+		0xec,0x8b,0xfb,0x00,0xea,0x88,0xfa,0x00,0xe9,0x87,0xf9,0x00,0xe8,0x84,0xf9,0x00,0xe6,0x82,0xf9,0x00,0xe4,0x80,0xf8,0x00,
+		0xe4,0x7e,0xf7,0x00,0xe1,0x7c,0xf7,0x00,0xe0,0x7a,0xf6,0x00,0xdd,0x74,0xf5,0x00,0xe0,0x7e,0xf5,0x00,0xff,0xeb,0xff,0x00,
+		0xc8,0xff,0xee,0x00,0x56,0xf0,0xcc,0x00,0x5a,0xf0,0xce,0x00,0x5b,0xef,0xcd,0x00,0x5b,0xef,0xcc,0x00,0x59,0xef,0xcb,0x00,
+		0x59,0xef,0xcb,0x00,0x59,0xef,0xca,0x00,0x59,0xee,0xc9,0x00,0x58,0xee,0xc8,0x00,0x57,0xee,0xc8,0x00,0x57,0xed,0xc7,0x00,
+		0x56,0xed,0xc6,0x00,0x55,0xed,0xc5,0x00,0x55,0xed,0xc5,0x00,0x54,0xec,0xc4,0x00,0x54,0xec,0xc3,0x00,0x54,0xeb,0xc2,0x00,
+		0x53,0xeb,0xc1,0x00,0x52,0xeb,0xc0,0x00,0x52,0xeb,0xc0,0x00,0x4b,0xe9,0xbd,0x00,0x44,0xe9,0xb9,0x00,0x68,0xee,0xc9,0x00,
+		0xbd,0xf7,0xe4,0x00,0xf5,0xfd,0xf8,0x00,0xef,0xf2,0xf1,0x00,0xa5,0xb6,0xaf,0x00,0x98,0xaa,0xa3,0x00,0x98,0xa6,0xa0,0x00,
+		0x95,0xa2,0x9d,0x00,0x94,0x9f,0x9b,0x00,0x91,0x9a,0x97,0x00,0x8f,0x98,0x95,0x00,0x8e,0x95,0x93,0x00,0x8e,0x94,0x92,0x00,
+		0x8e,0x92,0x91,0x00,0x8e,0x92,0x91,0x00,0x8f,0x92,0x91,0x00,0x90,0x92,0x92,0x00,0x91,0x93,0x92,0x00,0x91,0x93,0x92,0x00,
+		0x91,0x93,0x93,0x00,0x92,0x93,0x93,0x00,0x95,0x96,0x97,0x00,0x9c,0x9d,0x9e,0x00,0x9f,0xa1,0xa1,0x00,0xa0,0xa0,0xa1,0x00,
+		0x9f,0xa0,0xa0,0x00,0x9e,0x9e,0x9f,0x00,0x9d,0x9e,0x9f,0x00,0x9c,0x9d,0x9e,0x00,0x9b,0x9c,0x9d,0x00,0x9b,0x9c,0x9c,0x00,
+		0x9b,0x9b,0x9c,0x00,0x9b,0x9b,0x9c,0x00,0x9b,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9b,0x9b,0x9b,0x00,0x9b,0x9b,0x9b,0x00,
+		0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,0x9a,0x9b,0x9b,0x00,
+		0x9a,0x9a,0x9b,0x00,0x98,0x99,0x9a,0x00,0x96,0x96,0x98,0x00,0x94,0x95,0x95,0x00,0x90,0x90,0x90,0x00,0x8a,0x8a,0x8a,0x00,
+		0x82,0x83,0x83,0x00,0x79,0x79,0x7a,0x00,0x70,0x71,0x72,0x00,0x69,0x69,0x6a,0x00,0x63,0x63,0x64,0x00,0x60,0x60,0x61,0x00,
+		0x61,0x61,0x62,0x00,0x65,0x65,0x66,0x00,0x6b,0x6c,0x6c,0x00,0x74,0x74,0x75,0x00,0x7e,0x7e,0x7e,0x00,0x86,0x86,0x87,0x00,
+		0x8f,0x8f,0x90,0x00,0x95,0x95,0x95,0x00,0x9b,0x9b,0x9b,0x00,0x9f,0x9f,0x9e,0x00,0xa2,0xa1,0xa1,0x00,0xa4,0xa4,0xa2,0x00,
+		0xa5,0xa5,0xa3,0x00,0xa6,0xa5,0xa3,0x00,0xa6,0xa6,0xa3,0x00,0xa7,0xa6,0xa2,0x00,0xa7,0xa6,0xa1,0x00,0xa7,0xa6,0xa1,0x00,
+		0xa8,0xa6,0xa1,0x00,0xa7,0xa5,0x9e,0x00,0xa7,0xa5,0x9d,0x00,0xa8,0xa5,0x9b,0x00,0xa9,0xa6,0x9b,0x00,0xaa,0xa6,0x9a,0x00,
+		0xab,0xa6,0x99,0x00,0xad,0xa7,0x99,0x00,0xaf,0xa9,0x98,0x00,0xb2,0xab,0x99,0x00,0xb3,0xac,0x99,0x00,0xb4,0xac,0x98,0x00,
+		0xb6,0xad,0x97,0x00,0xb7,0xaf,0x97,0x00,0xb8,0xb0,0x96,0x00,0xb9,0xb1,0x96,0x00,0xb9,0xb0,0x95,0x00,0xba,0xb1,0x95,0x00,
+		0xbb,0xb1,0x94,0x00,0xba,0xb0,0x92,0x00,0xb6,0xac,0x8c,0x00,0xb3,0xa7,0x84,0x00,0xb0,0xa4,0x80,0x00,0xb0,0xa3,0x7f,0x00,
+		0xae,0xa2,0x7e,0x00,0xaf,0xa2,0x7e,0x00,0xaf,0xa2,0x7d,0x00,0xaf,0xa2,0x7d,0x00,0xaf,0xa2,0x7d,0x00,0xaf,0xa2,0x7d,0x00,
+		0xaf,0xa2,0x7d,0x00,0xaf,0xa2,0x7d,0x00,0xaf,0xa3,0x7d,0x00,0xb0,0xa3,0x7d,0x00,0xb0,0xa3,0x7d,0x00,0xaf,0xa1,0x7d,0x00,
+		0xaf,0xa2,0x7d,0x00,0xb0,0xa3,0x7d,0x00,0xb0,0xa3,0x7d,0x00,0xaf,0xa2,0x7c,0x00,0xb0,0xa2,0x7d,0x00,0xaf,0xa2,0x7c,0x00,
+		0xae,0xa2,0x7d,0x00,0xae,0xa1,0x7d,0x00,0xae,0xa1,0x7c,0x00,0xae,0xa1,0x7d,0x00,0xae,0xa2,0x7d,0x00,0xae,0xa1,0x7f,0x00,
+		0xae,0xa1,0x7e,0x00,0xad,0xa1,0x7e,0x00,0xaa,0x9e,0x7d,0x00,0xa9,0x9d,0x7c,0x00,0xa7,0x9b,0x7a,0x00,0xa2,0x96,0x75,0x00,
+		0x9b,0x8f,0x6f,0x00,0x92,0x86,0x66,0x00,0x84,0x79,0x59,0x00,0x78,0x6c,0x4c,0x00,0x69,0x5e,0x3e,0x00,0x5d,0x51,0x30,0x00,
+		0x4f,0x45,0x23,0x00,0x45,0x39,0x19,0x00,0x3d,0x32,0x10,0x00,0x38,0x2c,0x0a,0x00,0x35,0x28,0x06,0x00,0x32,0x26,0x02,0x00,
+		0x32,0x25,0x01,0x00,0x32,0x25,0x00,0x00,0x33,0x25,0x00,0x00,0x34,0x26,0x00,0x00,0x35,0x27,0x00,0x00,0x35,0x28,0x00,0x00,
+		0x35,0x28,0x00,0x00,0x36,0x28,0x00,0x00,0x36,0x29,0x00,0x00,0x37,0x28,0x00,0x00,0x37,0x28,0x00,0x00,0x37,0x28,0x00,0x00,
+		0x35,0x27,0x00,0x00,0x36,0x27,0x00,0x00,0x35,0x27,0x00,0x00,0x33,0x26,0x00,0x00,0x33,0x25,0x00,0x00,0x30,0x24,0x00,0x00,
+		0x2f,0x23,0x00,0x00,0x2d,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,0x29,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,
+		0x22,0x19,0x00,0x00,0x20,0x18,0x00,0x00,0x1d,0x16,0x00,0x00,0x1c,0x14,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,
+		0x15,0x10,0x00,0x00,0x13,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0c,0x0a,0x00,0x00,0x0c,0x08,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x04,0x03,0x05,0x00,
+		0x05,0x03,0x06,0x00,0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x06,0x0d,0x00,0x0e,0x07,0x10,0x00,
+		0x11,0x09,0x12,0x00,0x12,0x0a,0x15,0x00,0x15,0x0b,0x18,0x00,0x18,0x0e,0x1c,0x00,0x1b,0x0f,0x1f,0x00,0x20,0x11,0x23,0x00,
+		0x23,0x13,0x27,0x00,0x27,0x15,0x2c,0x00,0x2a,0x16,0x30,0x00,0x2f,0x18,0x35,0x00,0x31,0x1a,0x38,0x00,0x35,0x1c,0x3d,0x00,
+		0x3a,0x1f,0x41,0x00,0x3e,0x20,0x45,0x00,0x41,0x22,0x49,0x00,0x44,0x24,0x4d,0x00,0x49,0x26,0x51,0x00,0x4d,0x2a,0x57,0x00,
+		0x54,0x2e,0x5d,0x00,0x59,0x32,0x64,0x00,0x60,0x38,0x6b,0x00,0x69,0x41,0x74,0x00,0x73,0x4b,0x7e,0x00,0x80,0x55,0x8b,0x00,
+		0x8b,0x60,0x96,0x00,0x97,0x6b,0xa1,0x00,0x9f,0x74,0xab,0x00,0xa6,0x7b,0xb2,0x00,0xae,0x84,0xba,0x00,0xb4,0x89,0xbf,0x00,
+		0xb6,0x8c,0xc2,0x00,0xe0,0xd0,0xe6,0x00,0xf9,0xf7,0xf9,0x00,0xfe,0xfa,0xfe,0x00,0xfe,0xd1,0xfe,0x00,0xfc,0xa9,0xfe,0x00,
+		0xfb,0x9b,0xfd,0x00,0xf9,0x9f,0xfd,0x00,0xf7,0x9d,0xfd,0x00,0xf7,0x9a,0xfd,0x00,0xf6,0x9a,0xfd,0x00,0xf5,0x97,0xfd,0x00,
+		0xf4,0x96,0xfd,0x00,0xf3,0x94,0xfd,0x00,0xf1,0x92,0xfc,0x00,0xef,0x90,0xfc,0x00,0xee,0x8e,0xfb,0x00,0xed,0x8c,0xfa,0x00,
+		0xeb,0x8a,0xfa,0x00,0xe9,0x87,0xf9,0x00,0xe8,0x86,0xf9,0x00,0xe7,0x83,0xf8,0x00,0xe5,0x81,0xf8,0x00,0xe4,0x7f,0xf7,0x00,
+		0xe3,0x7e,0xf7,0x00,0xdf,0x77,0xf6,0x00,0xe1,0x82,0xf6,0x00,0xff,0xeb,0xff,0x00,0xc8,0xff,0xef,0x00,0x56,0xf0,0xce,0x00,
+		0x5a,0xf0,0xce,0x00,0x5b,0xf0,0xcd,0x00,0x5b,0xef,0xcd,0x00,0x5b,0xf0,0xcd,0x00,0x5a,0xef,0xcc,0x00,0x59,0xef,0xcb,0x00,
+		0x59,0xef,0xca,0x00,0x59,0xee,0xc9,0x00,0x58,0xee,0xc9,0x00,0x57,0xee,0xc7,0x00,0x57,0xee,0xc7,0x00,0x56,0xed,0xc6,0x00,
+		0x56,0xed,0xc6,0x00,0x54,0xed,0xc4,0x00,0x54,0xec,0xc4,0x00,0x54,0xec,0xc3,0x00,0x54,0xeb,0xc2,0x00,0x51,0xeb,0xc1,0x00,
+		0x47,0xea,0xbc,0x00,0x5a,0xeb,0xc3,0x00,0xa7,0xf4,0xde,0x00,0xf2,0xfd,0xfa,0x00,0xf9,0xfb,0xfa,0x00,0xd3,0xdd,0xd9,0x00,
+		0xa5,0xb7,0xb0,0x00,0x96,0xa9,0xa2,0x00,0x95,0xa6,0xa0,0x00,0x94,0xa2,0x9c,0x00,0x90,0x9d,0x98,0x00,0x8d,0x98,0x94,0x00,
+		0x8a,0x94,0x90,0x00,0x88,0x8f,0x8d,0x00,0x86,0x8c,0x8a,0x00,0x85,0x8a,0x88,0x00,0x84,0x89,0x87,0x00,0x86,0x89,0x88,0x00,
+		0x87,0x8a,0x89,0x00,0x88,0x8b,0x8a,0x00,0x89,0x8b,0x8b,0x00,0x89,0x8b,0x8b,0x00,0x8c,0x8d,0x8d,0x00,0x91,0x92,0x92,0x00,
+		0x99,0x9a,0x9a,0x00,0x9c,0x9d,0x9d,0x00,0x9c,0x9c,0x9d,0x00,0x9b,0x9b,0x9c,0x00,0x9b,0x9b,0x9b,0x00,0x9a,0x9a,0x9b,0x00,
+		0x99,0x9a,0x9b,0x00,0x98,0x99,0x99,0x00,0x98,0x98,0x99,0x00,0x96,0x97,0x98,0x00,0x96,0x97,0x97,0x00,0x96,0x96,0x97,0x00,
+		0x95,0x96,0x97,0x00,0x96,0x96,0x97,0x00,0x95,0x96,0x97,0x00,0x95,0x96,0x97,0x00,0x95,0x96,0x97,0x00,0x95,0x96,0x96,0x00,
+		0x95,0x96,0x96,0x00,0x95,0x96,0x96,0x00,0x95,0x96,0x97,0x00,0x95,0x96,0x97,0x00,0x95,0x95,0x96,0x00,0x94,0x94,0x95,0x00,
+		0x92,0x93,0x93,0x00,0x8f,0x90,0x90,0x00,0x8a,0x8a,0x8b,0x00,0x84,0x84,0x84,0x00,0x7c,0x7d,0x7d,0x00,0x73,0x73,0x74,0x00,
+		0x6b,0x6b,0x6c,0x00,0x62,0x62,0x63,0x00,0x5c,0x5c,0x5d,0x00,0x5a,0x5a,0x5b,0x00,0x5a,0x5b,0x5b,0x00,0x5d,0x5e,0x5e,0x00,
+		0x65,0x65,0x65,0x00,0x6d,0x6d,0x6e,0x00,0x77,0x77,0x77,0x00,0x80,0x81,0x81,0x00,0x89,0x89,0x89,0x00,0x8f,0x90,0x90,0x00,
+		0x95,0x95,0x95,0x00,0x99,0x99,0x99,0x00,0x9c,0x9c,0x9b,0x00,0x9f,0x9e,0x9d,0x00,0x9f,0x9f,0x9d,0x00,0xa0,0xa0,0x9d,0x00,
+		0xa1,0xa0,0x9d,0x00,0xa1,0xa1,0x9d,0x00,0xa1,0x9f,0x9b,0x00,0xa1,0xa0,0x9b,0x00,0xa2,0xa0,0x9a,0x00,0xa1,0x9e,0x98,0x00,
+		0xa1,0x9e,0x96,0x00,0xa1,0x9e,0x95,0x00,0xa1,0x9e,0x94,0x00,0xa2,0x9f,0x93,0x00,0xa4,0xa0,0x93,0x00,0xa6,0xa1,0x93,0x00,
+		0xa7,0xa2,0x93,0x00,0xaa,0xa4,0x93,0x00,0xac,0xa6,0x93,0x00,0xae,0xa7,0x94,0x00,0xb0,0xa9,0x94,0x00,0xb2,0xa9,0x94,0x00,
+		0xb2,0xab,0x93,0x00,0xb3,0xab,0x93,0x00,0xb4,0xab,0x92,0x00,0xb3,0xaa,0x90,0x00,0xb1,0xa7,0x8c,0x00,0xac,0xa2,0x84,0x00,
+		0xa9,0x9f,0x7f,0x00,0xa9,0x9e,0x7c,0x00,0xa8,0x9d,0x7c,0x00,0xa9,0x9d,0x7c,0x00,0xa8,0x9c,0x7a,0x00,0xa8,0x9c,0x7a,0x00,
+		0xa7,0x9b,0x79,0x00,0xa7,0x9c,0x79,0x00,0xa8,0x9b,0x79,0x00,0xa8,0x9c,0x79,0x00,0xa8,0x9c,0x79,0x00,0xa8,0x9c,0x78,0x00,
+		0xa8,0x9c,0x78,0x00,0xa8,0x9b,0x78,0x00,0xa8,0x9c,0x78,0x00,0xa9,0x9c,0x78,0x00,0xa8,0x9b,0x77,0x00,0xa9,0x9d,0x78,0x00,
+		0xa9,0x9d,0x78,0x00,0xa8,0x9c,0x78,0x00,0xa9,0x9d,0x78,0x00,0xa9,0x9d,0x78,0x00,0xa8,0x9c,0x78,0x00,0xa8,0x9b,0x78,0x00,
+		0xa8,0x9c,0x78,0x00,0xa8,0x9c,0x78,0x00,0xa8,0x9b,0x79,0x00,0xa7,0x9a,0x78,0x00,0xa6,0x9b,0x78,0x00,0xa6,0x9a,0x78,0x00,
+		0xa4,0x98,0x77,0x00,0xa2,0x97,0x76,0x00,0x9f,0x93,0x73,0x00,0x99,0x8d,0x6e,0x00,0x92,0x86,0x68,0x00,0x89,0x7e,0x5f,0x00,
+		0x7e,0x73,0x54,0x00,0x70,0x65,0x46,0x00,0x63,0x59,0x39,0x00,0x56,0x4b,0x2c,0x00,0x4b,0x40,0x20,0x00,0x40,0x36,0x15,0x00,
+		0x3a,0x2f,0x0f,0x00,0x34,0x28,0x08,0x00,0x32,0x26,0x05,0x00,0x30,0x24,0x02,0x00,0x30,0x23,0x01,0x00,0x30,0x23,0x00,0x00,
+		0x30,0x24,0x00,0x00,0x31,0x24,0x00,0x00,0x31,0x25,0x00,0x00,0x32,0x26,0x00,0x00,0x34,0x26,0x00,0x00,0x33,0x26,0x00,0x00,
+		0x34,0x26,0x00,0x00,0x34,0x26,0x00,0x00,0x34,0x27,0x00,0x00,0x34,0x26,0x00,0x00,0x33,0x25,0x00,0x00,0x33,0x25,0x00,0x00,
+		0x32,0x24,0x00,0x00,0x31,0x24,0x00,0x00,0x2f,0x23,0x00,0x00,0x2e,0x22,0x00,0x00,0x2d,0x22,0x00,0x00,0x2b,0x20,0x00,0x00,
+		0x29,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,0x22,0x19,0x00,0x00,0x1f,0x16,0x00,0x00,
+		0x1d,0x15,0x00,0x00,0x19,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x14,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x01,0x02,0x00,
+		0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,0x04,0x02,0x04,0x00,0x04,0x03,0x04,0x00,0x05,0x04,0x06,0x00,0x06,0x04,0x07,0x00,
+		0x08,0x05,0x09,0x00,0x09,0x05,0x0b,0x00,0x0c,0x07,0x0d,0x00,0x0e,0x07,0x0f,0x00,0x0f,0x09,0x11,0x00,0x12,0x0a,0x14,0x00,
+		0x14,0x0c,0x17,0x00,0x17,0x0d,0x1b,0x00,0x1b,0x0f,0x1e,0x00,0x1e,0x11,0x22,0x00,0x21,0x13,0x25,0x00,0x25,0x15,0x2a,0x00,
+		0x28,0x16,0x2e,0x00,0x2c,0x18,0x33,0x00,0x30,0x1b,0x37,0x00,0x34,0x1c,0x3b,0x00,0x38,0x1e,0x3f,0x00,0x3c,0x1f,0x43,0x00,
+		0x3f,0x21,0x47,0x00,0x43,0x24,0x4c,0x00,0x47,0x25,0x4e,0x00,0x4c,0x29,0x54,0x00,0x51,0x2c,0x59,0x00,0x57,0x31,0x61,0x00,
+		0x5f,0x38,0x69,0x00,0x68,0x40,0x72,0x00,0x73,0x4a,0x7c,0x00,0x7c,0x54,0x87,0x00,0x89,0x5f,0x94,0x00,0x93,0x6a,0x9e,0x00,
+		0x9c,0x73,0xa7,0x00,0xa6,0x7c,0xb1,0x00,0xac,0x82,0xb7,0x00,0xb2,0x89,0xbe,0x00,0xb6,0x8d,0xc1,0x00,0xb5,0x8f,0xc2,0x00,
+		0xc8,0xac,0xd2,0x00,0xeb,0xe1,0xef,0x00,0xfd,0xfd,0xfd,0x00,0xfc,0xef,0xfc,0x00,0xfe,0xc5,0xfe,0x00,0xfb,0xa2,0xfd,0x00,
+		0xfb,0x9a,0xfe,0x00,0xf9,0x9d,0xfe,0x00,0xf7,0x9d,0xfd,0x00,0xf7,0x9a,0xfe,0x00,0xf6,0x9a,0xfe,0x00,0xf4,0x96,0xfd,0x00,
+		0xf2,0x94,0xfc,0x00,0xf1,0x92,0xfb,0x00,0xf0,0x91,0xfc,0x00,0xef,0x8f,0xfc,0x00,0xee,0x8d,0xfb,0x00,0xec,0x8a,0xfa,0x00,
+		0xea,0x88,0xf9,0x00,0xe9,0x86,0xf9,0x00,0xe8,0x85,0xf9,0x00,0xe6,0x83,0xf8,0x00,0xe5,0x81,0xf8,0x00,0xe2,0x7a,0xf7,0x00,
+		0xe4,0x85,0xf8,0x00,0xff,0xec,0xff,0x00,0xc8,0xff,0xef,0x00,0x57,0xf1,0xcf,0x00,0x5c,0xf0,0xd0,0x00,0x5d,0xf1,0xd0,0x00,
+		0x5c,0xf0,0xcf,0x00,0x5c,0xef,0xce,0x00,0x5b,0xf0,0xce,0x00,0x5a,0xef,0xcc,0x00,0x5a,0xef,0xcb,0x00,0x59,0xef,0xca,0x00,
+		0x59,0xef,0xca,0x00,0x58,0xee,0xc9,0x00,0x58,0xed,0xc8,0x00,0x57,0xee,0xc7,0x00,0x57,0xee,0xc7,0x00,0x56,0xed,0xc6,0x00,
+		0x56,0xed,0xc5,0x00,0x53,0xed,0xc4,0x00,0x4a,0xeb,0xc0,0x00,0x4f,0xeb,0xc1,0x00,0x91,0xf2,0xd8,0x00,0xe2,0xfc,0xf4,0x00,
+		0xff,0xff,0xff,0x00,0xde,0xe7,0xe3,0x00,0xad,0xc1,0xba,0x00,0x97,0xad,0xa5,0x00,0x96,0xaa,0xa2,0x00,0x94,0xa6,0x9f,0x00,
+		0x92,0xa1,0x9b,0x00,0x8e,0x9c,0x96,0x00,0x8a,0x96,0x91,0x00,0x85,0x90,0x8c,0x00,0x81,0x8a,0x87,0x00,0x7e,0x85,0x82,0x00,
+		0x7b,0x81,0x7f,0x00,0x79,0x7f,0x7d,0x00,0x79,0x7d,0x7c,0x00,0x7b,0x7e,0x7d,0x00,0x7c,0x7f,0x7e,0x00,0x7e,0x80,0x80,0x00,
+		0x80,0x81,0x81,0x00,0x83,0x85,0x85,0x00,0x8c,0x8d,0x8d,0x00,0x93,0x94,0x95,0x00,0x95,0x96,0x96,0x00,0x95,0x96,0x96,0x00,
+		0x95,0x95,0x96,0x00,0x95,0x95,0x95,0x00,0x94,0x95,0x95,0x00,0x94,0x94,0x95,0x00,0x93,0x94,0x94,0x00,0x91,0x92,0x93,0x00,
+		0x91,0x92,0x92,0x00,0x91,0x91,0x92,0x00,0x90,0x90,0x91,0x00,0x90,0x90,0x90,0x00,0x90,0x90,0x90,0x00,0x90,0x90,0x90,0x00,
+		0x8f,0x90,0x90,0x00,0x90,0x90,0x91,0x00,0x90,0x90,0x91,0x00,0x90,0x91,0x91,0x00,0x90,0x90,0x90,0x00,0x90,0x90,0x91,0x00,
+		0x90,0x90,0x91,0x00,0x90,0x90,0x91,0x00,0x90,0x90,0x90,0x00,0x8e,0x8f,0x8f,0x00,0x8b,0x8c,0x8c,0x00,0x88,0x89,0x89,0x00,
+		0x83,0x84,0x84,0x00,0x7d,0x7d,0x7e,0x00,0x75,0x75,0x76,0x00,0x6c,0x6d,0x6d,0x00,0x63,0x63,0x64,0x00,0x5c,0x5c,0x5c,0x00,
+		0x56,0x57,0x57,0x00,0x53,0x53,0x54,0x00,0x53,0x54,0x54,0x00,0x57,0x57,0x58,0x00,0x5d,0x5e,0x5e,0x00,0x66,0x67,0x67,0x00,
+		0x70,0x70,0x70,0x00,0x79,0x79,0x79,0x00,0x81,0x81,0x81,0x00,0x89,0x89,0x89,0x00,0x8e,0x8e,0x8e,0x00,0x92,0x91,0x91,0x00,
+		0x95,0x95,0x95,0x00,0x97,0x97,0x96,0x00,0x98,0x97,0x96,0x00,0x99,0x98,0x96,0x00,0x99,0x98,0x96,0x00,0x99,0x98,0x95,0x00,
+		0x99,0x98,0x94,0x00,0x99,0x98,0x93,0x00,0x98,0x96,0x91,0x00,0x98,0x95,0x90,0x00,0x98,0x95,0x8e,0x00,0x97,0x94,0x8c,0x00,
+		0x98,0x95,0x8b,0x00,0x99,0x95,0x8a,0x00,0x9a,0x95,0x8a,0x00,0x9c,0x98,0x8a,0x00,0x9e,0x99,0x8a,0x00,0xa1,0x9b,0x8c,0x00,
+		0xa3,0x9d,0x8c,0x00,0xa6,0x9f,0x8c,0x00,0xa7,0xa1,0x8e,0x00,0xa9,0xa2,0x8d,0x00,0xab,0xa3,0x8e,0x00,0xab,0xa3,0x8c,0x00,
+		0xa9,0xa0,0x88,0x00,0xa5,0x9c,0x81,0x00,0xa1,0x97,0x7b,0x00,0x9e,0x94,0x78,0x00,0x9f,0x94,0x76,0x00,0x9f,0x95,0x76,0x00,
+		0xa0,0x95,0x76,0x00,0x9e,0x94,0x75,0x00,0x9e,0x93,0x74,0x00,0x9f,0x93,0x74,0x00,0x9e,0x92,0x73,0x00,0x9d,0x92,0x72,0x00,
+		0x9e,0x92,0x73,0x00,0x9e,0x93,0x72,0x00,0x9e,0x93,0x72,0x00,0x9d,0x92,0x71,0x00,0x9f,0x93,0x72,0x00,0x9f,0x94,0x72,0x00,
+		0x9e,0x92,0x72,0x00,0x9f,0x93,0x71,0x00,0x9f,0x93,0x72,0x00,0xa0,0x94,0x72,0x00,0x9f,0x93,0x71,0x00,0x9f,0x93,0x71,0x00,
+		0xa0,0x94,0x71,0x00,0xa0,0x94,0x71,0x00,0xa0,0x94,0x72,0x00,0x9f,0x93,0x72,0x00,0x9f,0x93,0x71,0x00,0x9f,0x93,0x72,0x00,
+		0x9e,0x93,0x71,0x00,0x9e,0x92,0x71,0x00,0x9d,0x92,0x72,0x00,0x9c,0x91,0x70,0x00,0x9b,0x90,0x70,0x00,0x99,0x8f,0x6e,0x00,
+		0x95,0x8a,0x6c,0x00,0x90,0x84,0x67,0x00,0x89,0x7e,0x5f,0x00,0x7e,0x75,0x56,0x00,0x75,0x6a,0x4c,0x00,0x69,0x5e,0x40,0x00,
+		0x5c,0x51,0x34,0x00,0x50,0x46,0x28,0x00,0x45,0x3b,0x1d,0x00,0x3d,0x32,0x14,0x00,0x36,0x2b,0x0d,0x00,0x31,0x27,0x07,0x00,
+		0x2f,0x24,0x04,0x00,0x2d,0x21,0x02,0x00,0x2d,0x21,0x01,0x00,0x2d,0x21,0x00,0x00,0x2e,0x22,0x00,0x00,0x2e,0x23,0x00,0x00,
+		0x2f,0x23,0x00,0x00,0x30,0x23,0x00,0x00,0x30,0x24,0x00,0x00,0x30,0x24,0x00,0x00,0x30,0x24,0x00,0x00,0x31,0x25,0x00,0x00,
+		0x31,0x25,0x00,0x00,0x31,0x24,0x00,0x00,0x30,0x23,0x00,0x00,0x30,0x23,0x00,0x00,0x30,0x23,0x00,0x00,0x2f,0x23,0x00,0x00,
+		0x2e,0x22,0x00,0x00,0x2c,0x21,0x00,0x00,0x2b,0x1f,0x00,0x00,0x29,0x1f,0x00,0x00,0x27,0x1d,0x00,0x00,0x25,0x1c,0x00,0x00,
+		0x23,0x1a,0x00,0x00,0x21,0x19,0x00,0x00,0x1f,0x17,0x00,0x00,0x1d,0x16,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x12,0x00,0x00,
+		0x17,0x12,0x00,0x00,0x15,0x0f,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0d,0x0b,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x04,0x04,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x17,0x17,0x17,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x07,0x07,0x07,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x02,0x00,0x02,0x01,0x02,0x00,0x03,0x02,0x03,0x00,
+		0x03,0x02,0x04,0x00,0x04,0x03,0x04,0x00,0x05,0x03,0x05,0x00,0x06,0x04,0x07,0x00,0x08,0x04,0x08,0x00,0x09,0x05,0x0a,0x00,
+		0x0b,0x06,0x0c,0x00,0x0e,0x08,0x0f,0x00,0x0f,0x08,0x11,0x00,0x12,0x0a,0x13,0x00,0x13,0x0c,0x16,0x00,0x16,0x0d,0x1a,0x00,
+		0x1a,0x0f,0x1d,0x00,0x1d,0x11,0x21,0x00,0x21,0x12,0x25,0x00,0x25,0x15,0x28,0x00,0x28,0x17,0x2d,0x00,0x2c,0x18,0x31,0x00,
+		0x2f,0x1a,0x35,0x00,0x33,0x1c,0x39,0x00,0x37,0x1d,0x3d,0x00,0x3a,0x20,0x41,0x00,0x3e,0x21,0x45,0x00,0x43,0x25,0x4b,0x00,
+		0x46,0x27,0x4f,0x00,0x4a,0x29,0x52,0x00,0x4f,0x2d,0x58,0x00,0x55,0x32,0x5f,0x00,0x5d,0x38,0x67,0x00,0x66,0x3f,0x6f,0x00,
+		0x6e,0x48,0x78,0x00,0x79,0x52,0x83,0x00,0x84,0x5d,0x8e,0x00,0x8e,0x66,0x99,0x00,0x98,0x70,0xa3,0x00,0xa2,0x79,0xac,0x00,
+		0xa9,0x81,0xb4,0x00,0xad,0x86,0xb9,0x00,0xb3,0x8b,0xbe,0x00,0xb5,0x8f,0xc1,0x00,0xb7,0x92,0xc2,0x00,0xb8,0x96,0xc5,0x00,
+		0xd0,0xbc,0xd8,0x00,0xf0,0xeb,0xf3,0x00,0xfd,0xfd,0xfd,0x00,0xfd,0xe6,0xfd,0x00,0xfd,0xba,0xfe,0x00,0xfc,0x9e,0xff,0x00,
+		0xfa,0x9b,0xfe,0x00,0xf9,0x9f,0xff,0x00,0xf7,0x9c,0xfd,0x00,0xf7,0x9b,0xfe,0x00,0xf5,0x97,0xfd,0x00,0xf4,0x96,0xfd,0x00,
+		0xf2,0x95,0xfd,0x00,0xf1,0x93,0xfc,0x00,0xf0,0x90,0xfc,0x00,0xee,0x8e,0xfb,0x00,0xed,0x8c,0xfb,0x00,0xeb,0x8a,0xfa,0x00,
+		0xe9,0x88,0xf9,0x00,0xe8,0x86,0xf9,0x00,0xe8,0x85,0xf9,0x00,0xe5,0x7e,0xf8,0x00,0xe5,0x88,0xf8,0x00,0xff,0xec,0xff,0x00,
+		0xc9,0xff,0xef,0x00,0x59,0xf1,0xd0,0x00,0x5c,0xf1,0xd1,0x00,0x5d,0xf1,0xd0,0x00,0x5d,0xf0,0xd0,0x00,0x5c,0xf0,0xcf,0x00,
+		0x5c,0xf0,0xce,0x00,0x5b,0xef,0xcd,0x00,0x5b,0xf0,0xcd,0x00,0x5a,0xf0,0xcc,0x00,0x59,0xef,0xcb,0x00,0x59,0xee,0xca,0x00,
+		0x59,0xee,0xca,0x00,0x58,0xee,0xc9,0x00,0x58,0xee,0xc8,0x00,0x58,0xee,0xc7,0x00,0x50,0xec,0xc4,0x00,0x4d,0xec,0xc2,0x00,
+		0x7d,0xf1,0xd2,0x00,0xd1,0xfa,0xee,0x00,0xff,0xff,0xff,0x00,0xeb,0xf1,0xef,0x00,0xb8,0xcc,0xc5,0x00,0x97,0xb1,0xa7,0x00,
+		0x95,0xad,0xa4,0x00,0x95,0xab,0xa2,0x00,0x92,0xa6,0x9f,0x00,0x90,0xa1,0x9a,0x00,0x8c,0x9b,0x95,0x00,0x86,0x93,0x8e,0x00,
+		0x80,0x8c,0x88,0x00,0x7b,0x85,0x81,0x00,0x76,0x7e,0x7b,0x00,0x71,0x78,0x76,0x00,0x6e,0x74,0x72,0x00,0x6c,0x71,0x6f,0x00,
+		0x6c,0x70,0x6f,0x00,0x6c,0x6f,0x6e,0x00,0x6e,0x71,0x70,0x00,0x72,0x74,0x73,0x00,0x77,0x79,0x79,0x00,0x82,0x84,0x84,0x00,
+		0x8b,0x8c,0x8c,0x00,0x8c,0x8c,0x8c,0x00,0x8c,0x8d,0x8d,0x00,0x8c,0x8d,0x8d,0x00,0x8c,0x8d,0x8d,0x00,0x8c,0x8c,0x8d,0x00,
+		0x8b,0x8c,0x8c,0x00,0x8a,0x8a,0x8b,0x00,0x8a,0x8a,0x8b,0x00,0x8a,0x8a,0x8a,0x00,0x88,0x89,0x8a,0x00,0x87,0x88,0x89,0x00,
+		0x87,0x87,0x89,0x00,0x87,0x87,0x88,0x00,0x86,0x87,0x87,0x00,0x86,0x87,0x87,0x00,0x86,0x86,0x87,0x00,0x87,0x87,0x88,0x00,
+		0x87,0x87,0x88,0x00,0x87,0x87,0x88,0x00,0x87,0x87,0x88,0x00,0x87,0x87,0x88,0x00,0x87,0x87,0x88,0x00,0x87,0x87,0x88,0x00,
+		0x85,0x86,0x86,0x00,0x84,0x84,0x85,0x00,0x83,0x83,0x84,0x00,0x7f,0x7f,0x80,0x00,0x7a,0x7a,0x7a,0x00,0x73,0x74,0x75,0x00,
+		0x6d,0x6d,0x6d,0x00,0x64,0x65,0x66,0x00,0x5c,0x5c,0x5d,0x00,0x54,0x55,0x55,0x00,0x4f,0x50,0x50,0x00,0x4c,0x4c,0x4d,0x00,
+		0x4c,0x4c,0x4d,0x00,0x50,0x50,0x51,0x00,0x56,0x57,0x57,0x00,0x5d,0x5d,0x5e,0x00,0x66,0x67,0x67,0x00,0x70,0x70,0x70,0x00,
+		0x78,0x78,0x78,0x00,0x7f,0x7f,0x7f,0x00,0x84,0x84,0x83,0x00,0x87,0x87,0x87,0x00,0x8a,0x8a,0x8a,0x00,0x8c,0x8c,0x8b,0x00,
+		0x8e,0x8d,0x8c,0x00,0x8e,0x8e,0x8c,0x00,0x8f,0x8e,0x8c,0x00,0x8f,0x8d,0x8a,0x00,0x8f,0x8d,0x8a,0x00,0x8d,0x8c,0x88,0x00,
+		0x8c,0x8a,0x86,0x00,0x8c,0x8a,0x84,0x00,0x8b,0x89,0x82,0x00,0x8b,0x88,0x81,0x00,0x8b,0x88,0x7f,0x00,0x8b,0x88,0x7e,0x00,
+		0x8e,0x8a,0x7f,0x00,0x90,0x8c,0x7f,0x00,0x93,0x8e,0x81,0x00,0x95,0x90,0x82,0x00,0x98,0x92,0x82,0x00,0x9b,0x95,0x84,0x00,
+		0x9d,0x96,0x84,0x00,0x9f,0x98,0x85,0x00,0x9f,0x97,0x84,0x00,0x9b,0x94,0x7e,0x00,0x97,0x8f,0x76,0x00,0x94,0x8b,0x71,0x00,
+		0x93,0x89,0x6f,0x00,0x93,0x8a,0x6e,0x00,0x92,0x89,0x6d,0x00,0x92,0x89,0x6d,0x00,0x92,0x88,0x6c,0x00,0x92,0x87,0x6b,0x00,
+		0x90,0x87,0x6a,0x00,0x91,0x87,0x6a,0x00,0x90,0x86,0x69,0x00,0x91,0x86,0x69,0x00,0x91,0x86,0x69,0x00,0x91,0x86,0x69,0x00,
+		0x91,0x86,0x68,0x00,0x91,0x87,0x68,0x00,0x91,0x86,0x68,0x00,0x92,0x87,0x68,0x00,0x92,0x86,0x68,0x00,0x92,0x87,0x68,0x00,
+		0x91,0x86,0x67,0x00,0x93,0x88,0x68,0x00,0x92,0x87,0x68,0x00,0x93,0x88,0x67,0x00,0x92,0x87,0x67,0x00,0x92,0x87,0x66,0x00,
+		0x92,0x87,0x66,0x00,0x93,0x88,0x67,0x00,0x92,0x87,0x66,0x00,0x92,0x87,0x67,0x00,0x91,0x86,0x66,0x00,0x91,0x86,0x67,0x00,
+		0x91,0x86,0x68,0x00,0x91,0x86,0x67,0x00,0x8f,0x84,0x65,0x00,0x8d,0x82,0x64,0x00,0x88,0x7d,0x5f,0x00,0x82,0x79,0x5b,0x00,
+		0x7d,0x73,0x55,0x00,0x74,0x6a,0x4d,0x00,0x6a,0x60,0x43,0x00,0x5f,0x55,0x38,0x00,0x54,0x49,0x2d,0x00,0x48,0x3e,0x21,0x00,
+		0x3e,0x35,0x18,0x00,0x38,0x2e,0x11,0x00,0x31,0x27,0x0a,0x00,0x2e,0x24,0x07,0x00,0x2b,0x21,0x03,0x00,0x2b,0x20,0x02,0x00,
+		0x2a,0x1f,0x01,0x00,0x2a,0x1f,0x00,0x00,0x2b,0x1f,0x00,0x00,0x2c,0x21,0x00,0x00,0x2d,0x21,0x00,0x00,0x2d,0x21,0x00,0x00,
+		0x2d,0x22,0x00,0x00,0x2e,0x22,0x00,0x00,0x2e,0x23,0x00,0x00,0x2e,0x21,0x00,0x00,0x2e,0x23,0x00,0x00,0x2e,0x22,0x00,0x00,
+		0x2e,0x23,0x00,0x00,0x2d,0x21,0x00,0x00,0x2d,0x21,0x00,0x00,0x2c,0x20,0x00,0x00,0x2b,0x1f,0x00,0x00,0x2a,0x1f,0x00,0x00,
+		0x29,0x1e,0x00,0x00,0x27,0x1c,0x00,0x00,0x25,0x1b,0x00,0x00,0x24,0x1a,0x00,0x00,0x22,0x19,0x00,0x00,0x20,0x17,0x00,0x00,
+		0x1e,0x16,0x00,0x00,0x1c,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x16,0x11,0x00,0x00,0x14,0x0e,0x00,0x00,
+		0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,0x0c,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1c,0x1c,0x1c,0x00,0x17,0x17,0x17,0x00,0x11,0x11,0x11,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x03,0x00,0x03,0x02,0x04,0x00,0x04,0x03,0x04,0x00,
+		0x04,0x03,0x05,0x00,0x05,0x04,0x06,0x00,0x07,0x04,0x08,0x00,0x09,0x05,0x0a,0x00,0x0a,0x06,0x0c,0x00,0x0c,0x07,0x0e,0x00,
+		0x0f,0x09,0x11,0x00,0x10,0x0a,0x13,0x00,0x13,0x0c,0x16,0x00,0x16,0x0d,0x19,0x00,0x19,0x0f,0x1c,0x00,0x1c,0x11,0x1f,0x00,
+		0x20,0x12,0x23,0x00,0x23,0x14,0x27,0x00,0x27,0x16,0x2b,0x00,0x2a,0x18,0x2e,0x00,0x2d,0x1a,0x33,0x00,0x31,0x1c,0x37,0x00,
+		0x35,0x1d,0x3b,0x00,0x39,0x20,0x3f,0x00,0x3d,0x21,0x44,0x00,0x40,0x24,0x47,0x00,0x44,0x26,0x4b,0x00,0x48,0x29,0x4f,0x00,
+		0x4d,0x2c,0x55,0x00,0x54,0x32,0x5b,0x00,0x5b,0x38,0x63,0x00,0x63,0x3e,0x6b,0x00,0x6b,0x46,0x74,0x00,0x76,0x50,0x7f,0x00,
+		0x80,0x59,0x89,0x00,0x8a,0x64,0x93,0x00,0x95,0x6e,0x9f,0x00,0x9d,0x76,0xa7,0x00,0xa5,0x7e,0xaf,0x00,0xaa,0x84,0xb5,0x00,
+		0xaf,0x8a,0xba,0x00,0xb2,0x8e,0xbd,0x00,0xb5,0x91,0xc1,0x00,0xb6,0x94,0xc3,0x00,0xb7,0x98,0xc4,0x00,0xbd,0xa2,0xca,0x00,
+		0xd9,0xcc,0xe1,0x00,0xf9,0xf7,0xfb,0x00,0xfe,0xfd,0xfe,0x00,0xfd,0xdc,0xfe,0x00,0xfd,0xb0,0xff,0x00,0xfb,0x9a,0xfe,0x00,
+		0xfa,0x9b,0xfe,0x00,0xf9,0x9d,0xff,0x00,0xf8,0x9b,0xff,0x00,0xf6,0x99,0xfe,0x00,0xf5,0x98,0xfe,0x00,0xf3,0x96,0xfd,0x00,
+		0xf2,0x93,0xfc,0x00,0xf0,0x91,0xfc,0x00,0xef,0x8e,0xfc,0x00,0xee,0x8d,0xfb,0x00,0xec,0x8b,0xfa,0x00,0xea,0x89,0xf9,0x00,
+		0xe9,0x87,0xf9,0x00,0xe7,0x81,0xf9,0x00,0xe8,0x8b,0xf9,0x00,0xff,0xed,0xff,0x00,0xc8,0xff,0xf0,0x00,0x5a,0xf2,0xd2,0x00,
+		0x5e,0xf2,0xd2,0x00,0x5e,0xf1,0xd2,0x00,0x5e,0xf1,0xd1,0x00,0x5d,0xf1,0xd0,0x00,0x5d,0xf0,0xd0,0x00,0x5c,0xf0,0xce,0x00,
+		0x5c,0xf0,0xce,0x00,0x5b,0xef,0xcd,0x00,0x5b,0xf0,0xcd,0x00,0x5a,0xef,0xcc,0x00,0x59,0xef,0xcb,0x00,0x59,0xef,0xca,0x00,
+		0x53,0xed,0xc8,0x00,0x4b,0xec,0xc5,0x00,0x6a,0xf0,0xce,0x00,0xbc,0xf8,0xe8,0x00,0xfa,0xfe,0xfd,0x00,0xf4,0xf8,0xf7,0x00,
+		0xc6,0xd7,0xd1,0x00,0x9c,0xb8,0xae,0x00,0x95,0xb0,0xa6,0x00,0x94,0xad,0xa5,0x00,0x93,0xaa,0xa2,0x00,0x90,0xa5,0x9d,0x00,
+		0x8e,0xa0,0x99,0x00,0x8a,0x9a,0x95,0x00,0x84,0x92,0x8d,0x00,0x7e,0x8a,0x86,0x00,0x77,0x82,0x7e,0x00,0x6f,0x78,0x75,0x00,
+		0x69,0x70,0x6d,0x00,0x63,0x69,0x67,0x00,0x5f,0x65,0x63,0x00,0x5d,0x62,0x60,0x00,0x5c,0x60,0x5f,0x00,0x5d,0x60,0x5f,0x00,
+		0x61,0x64,0x63,0x00,0x6a,0x6c,0x6b,0x00,0x76,0x77,0x77,0x00,0x7d,0x7f,0x7f,0x00,0x7f,0x80,0x80,0x00,0x80,0x81,0x81,0x00,
+		0x80,0x81,0x81,0x00,0x81,0x82,0x82,0x00,0x82,0x82,0x83,0x00,0x81,0x82,0x82,0x00,0x80,0x81,0x81,0x00,0x7f,0x80,0x80,0x00,
+		0x7f,0x7f,0x80,0x00,0x7f,0x7f,0x7f,0x00,0x7d,0x7e,0x7f,0x00,0x7e,0x7e,0x7f,0x00,0x7d,0x7d,0x7e,0x00,0x7c,0x7c,0x7d,0x00,
+		0x7c,0x7c,0x7d,0x00,0x7b,0x7c,0x7d,0x00,0x7b,0x7c,0x7d,0x00,0x7b,0x7c,0x7d,0x00,0x7c,0x7d,0x7e,0x00,0x7c,0x7d,0x7e,0x00,
+		0x7d,0x7d,0x7f,0x00,0x7d,0x7d,0x7e,0x00,0x7d,0x7e,0x7e,0x00,0x7c,0x7d,0x7d,0x00,0x7c,0x7c,0x7d,0x00,0x7a,0x7b,0x7b,0x00,
+		0x79,0x79,0x79,0x00,0x74,0x75,0x75,0x00,0x70,0x70,0x71,0x00,0x69,0x6a,0x6a,0x00,0x63,0x63,0x63,0x00,0x5c,0x5c,0x5c,0x00,
+		0x54,0x54,0x55,0x00,0x4d,0x4e,0x4e,0x00,0x48,0x49,0x49,0x00,0x46,0x46,0x46,0x00,0x46,0x47,0x47,0x00,0x49,0x49,0x4a,0x00,
+		0x4e,0x4f,0x4f,0x00,0x55,0x55,0x56,0x00,0x5d,0x5d,0x5d,0x00,0x65,0x65,0x65,0x00,0x6d,0x6d,0x6d,0x00,0x73,0x73,0x73,0x00,
+		0x78,0x78,0x78,0x00,0x7c,0x7c,0x7b,0x00,0x7e,0x7e,0x7d,0x00,0x7f,0x7f,0x7f,0x00,0x81,0x80,0x7f,0x00,0x82,0x81,0x7f,0x00,
+		0x82,0x81,0x7f,0x00,0x82,0x81,0x7f,0x00,0x81,0x80,0x7d,0x00,0x81,0x7f,0x7b,0x00,0x7f,0x7f,0x79,0x00,0x7f,0x7d,0x78,0x00,
+		0x7e,0x7c,0x76,0x00,0x7d,0x7a,0x73,0x00,0x7c,0x79,0x72,0x00,0x7e,0x7a,0x71,0x00,0x7f,0x7c,0x71,0x00,0x82,0x7e,0x73,0x00,
+		0x85,0x81,0x74,0x00,0x89,0x84,0x76,0x00,0x8a,0x85,0x77,0x00,0x8e,0x89,0x79,0x00,0x90,0x8a,0x79,0x00,0x8e,0x88,0x76,0x00,
+		0x89,0x82,0x6e,0x00,0x85,0x7e,0x67,0x00,0x82,0x7b,0x64,0x00,0x83,0x7a,0x62,0x00,0x83,0x7b,0x62,0x00,0x83,0x7b,0x62,0x00,
+		0x84,0x7b,0x61,0x00,0x84,0x7b,0x61,0x00,0x83,0x7a,0x60,0x00,0x83,0x7a,0x60,0x00,0x82,0x78,0x5e,0x00,0x82,0x78,0x5e,0x00,
+		0x81,0x77,0x5d,0x00,0x81,0x78,0x5d,0x00,0x80,0x77,0x5b,0x00,0x80,0x77,0x5b,0x00,0x80,0x77,0x5b,0x00,0x82,0x78,0x5c,0x00,
+		0x82,0x78,0x5c,0x00,0x82,0x78,0x5c,0x00,0x83,0x79,0x5c,0x00,0x83,0x79,0x5c,0x00,0x83,0x7a,0x5c,0x00,0x84,0x79,0x5c,0x00,
+		0x83,0x7a,0x5c,0x00,0x83,0x7a,0x5b,0x00,0x83,0x7a,0x5b,0x00,0x83,0x79,0x5a,0x00,0x84,0x7a,0x5b,0x00,0x83,0x7a,0x5b,0x00,
+		0x84,0x7a,0x5b,0x00,0x83,0x79,0x5a,0x00,0x83,0x79,0x5a,0x00,0x83,0x79,0x5a,0x00,0x83,0x79,0x5b,0x00,0x82,0x78,0x5a,0x00,
+		0x81,0x76,0x5a,0x00,0x7e,0x74,0x57,0x00,0x7a,0x70,0x54,0x00,0x75,0x6b,0x4f,0x00,0x6f,0x65,0x49,0x00,0x65,0x5b,0x41,0x00,
+		0x5e,0x54,0x39,0x00,0x54,0x4a,0x2f,0x00,0x4a,0x41,0x25,0x00,0x40,0x37,0x1c,0x00,0x39,0x2f,0x15,0x00,0x32,0x28,0x0e,0x00,
+		0x2e,0x24,0x09,0x00,0x2a,0x20,0x05,0x00,0x28,0x1e,0x03,0x00,0x27,0x1d,0x01,0x00,0x27,0x1d,0x00,0x00,0x27,0x1d,0x00,0x00,
+		0x28,0x1d,0x00,0x00,0x29,0x1e,0x00,0x00,0x29,0x1e,0x00,0x00,0x2a,0x1f,0x00,0x00,0x2b,0x20,0x00,0x00,0x2a,0x20,0x00,0x00,
+		0x2b,0x20,0x00,0x00,0x2b,0x21,0x00,0x00,0x2b,0x21,0x00,0x00,0x2b,0x21,0x00,0x00,0x2b,0x20,0x00,0x00,0x2a,0x1f,0x00,0x00,
+		0x2a,0x1f,0x00,0x00,0x29,0x1e,0x00,0x00,0x28,0x1e,0x00,0x00,0x27,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x23,0x1a,0x00,0x00,
+		0x23,0x1a,0x00,0x00,0x21,0x18,0x00,0x00,0x20,0x17,0x00,0x00,0x1e,0x16,0x00,0x00,0x1c,0x15,0x00,0x00,0x1a,0x13,0x00,0x00,
+		0x18,0x11,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x10,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x0f,0x0c,0x00,0x00,
+		0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x16,0x15,0x16,0x00,0x10,0x10,0x10,0x00,
+		0x0b,0x0a,0x0b,0x00,0x08,0x07,0x08,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x05,0x00,0x04,0x04,0x05,0x00,0x05,0x04,0x06,0x00,
+		0x07,0x04,0x08,0x00,0x08,0x05,0x09,0x00,0x0a,0x06,0x0b,0x00,0x0c,0x07,0x0d,0x00,0x0f,0x09,0x10,0x00,0x11,0x09,0x12,0x00,
+		0x14,0x0b,0x15,0x00,0x15,0x0c,0x17,0x00,0x18,0x0e,0x1b,0x00,0x1b,0x10,0x1f,0x00,0x1f,0x12,0x22,0x00,0x22,0x14,0x26,0x00,
+		0x25,0x16,0x29,0x00,0x28,0x17,0x2d,0x00,0x2c,0x1a,0x31,0x00,0x2f,0x1b,0x34,0x00,0x34,0x1d,0x38,0x00,0x37,0x1f,0x3d,0x00,
+		0x3b,0x22,0x42,0x00,0x3e,0x24,0x44,0x00,0x42,0x25,0x49,0x00,0x46,0x29,0x4d,0x00,0x4c,0x2c,0x53,0x00,0x51,0x30,0x59,0x00,
+		0x57,0x35,0x5f,0x00,0x5d,0x3b,0x64,0x00,0x68,0x44,0x6f,0x00,0x70,0x4c,0x79,0x00,0x7a,0x56,0x82,0x00,0x84,0x5f,0x8d,0x00,
+		0x8f,0x69,0x99,0x00,0x97,0x72,0xa1,0x00,0x9f,0x7a,0xa9,0x00,0xa5,0x80,0xaf,0x00,0xad,0x88,0xb7,0x00,0xb0,0x8b,0xba,0x00,
+		0xb3,0x90,0xbe,0x00,0xb5,0x94,0xc1,0x00,0xb5,0x97,0xc3,0x00,0xb4,0x98,0xc2,0x00,0xb5,0x9b,0xc4,0x00,0xbf,0xad,0xcd,0x00,
+		0xe2,0xdb,0xe9,0x00,0xfa,0xf9,0xfb,0x00,0xff,0xf9,0xff,0x00,0xfd,0xd0,0xfe,0x00,0xfc,0xa7,0xff,0x00,0xfb,0x9a,0xff,0x00,
+		0xfa,0x9d,0xff,0x00,0xf8,0x9d,0xfe,0x00,0xf7,0x9b,0xfe,0x00,0xf5,0x98,0xfe,0x00,0xf4,0x97,0xfd,0x00,0xf2,0x94,0xfc,0x00,
+		0xf1,0x93,0xfc,0x00,0xef,0x90,0xfc,0x00,0xee,0x8e,0xfb,0x00,0xed,0x8c,0xfa,0x00,0xeb,0x8a,0xfa,0x00,0xe8,0x84,0xf9,0x00,
+		0xea,0x8e,0xfa,0x00,0xff,0xed,0xff,0x00,0xc9,0xff,0xf0,0x00,0x5b,0xf2,0xd2,0x00,0x5e,0xf2,0xd3,0x00,0x5f,0xf2,0xd2,0x00,
+		0x5f,0xf1,0xd2,0x00,0x5d,0xf1,0xd1,0x00,0x5d,0xf0,0xd0,0x00,0x5d,0xf0,0xd0,0x00,0x5d,0xf0,0xcf,0x00,0x5c,0xf0,0xce,0x00,
+		0x5b,0xf0,0xce,0x00,0x5b,0xef,0xcd,0x00,0x59,0xef,0xcb,0x00,0x4e,0xee,0xc8,0x00,0x60,0xef,0xcc,0x00,0xa6,0xf6,0xe2,0x00,
+		0xf3,0xfe,0xfa,0x00,0xfa,0xfc,0xfb,0x00,0xd2,0xe1,0xdc,0x00,0xa1,0xbf,0xb4,0x00,0x93,0xb3,0xa7,0x00,0x94,0xb0,0xa6,0x00,
+		0x92,0xac,0xa4,0x00,0x91,0xa9,0xa1,0x00,0x8f,0xa4,0x9c,0x00,0x8b,0x9f,0x97,0x00,0x86,0x98,0x92,0x00,0x81,0x91,0x8b,0x00,
+		0x7a,0x88,0x83,0x00,0x73,0x7f,0x7a,0x00,0x6a,0x74,0x70,0x00,0x62,0x6a,0x67,0x00,0x5a,0x62,0x5f,0x00,0x53,0x5a,0x58,0x00,
+		0x4e,0x54,0x52,0x00,0x4c,0x51,0x4f,0x00,0x4d,0x50,0x4f,0x00,0x51,0x54,0x53,0x00,0x5a,0x5d,0x5c,0x00,0x69,0x6b,0x6a,0x00,
+		0x6d,0x6e,0x6e,0x00,0x6f,0x71,0x70,0x00,0x72,0x72,0x72,0x00,0x73,0x73,0x73,0x00,0x73,0x74,0x74,0x00,0x74,0x74,0x74,0x00,
+		0x73,0x74,0x74,0x00,0x73,0x74,0x74,0x00,0x73,0x73,0x74,0x00,0x73,0x73,0x74,0x00,0x73,0x73,0x73,0x00,0x72,0x72,0x73,0x00,
+		0x71,0x71,0x72,0x00,0x70,0x70,0x71,0x00,0x6f,0x6f,0x70,0x00,0x6f,0x70,0x70,0x00,0x6f,0x70,0x70,0x00,0x6f,0x6f,0x70,0x00,
+		0x6f,0x6f,0x70,0x00,0x6f,0x6f,0x70,0x00,0x6f,0x6f,0x70,0x00,0x70,0x70,0x71,0x00,0x70,0x70,0x71,0x00,0x70,0x70,0x71,0x00,
+		0x70,0x70,0x71,0x00,0x70,0x70,0x71,0x00,0x6f,0x70,0x70,0x00,0x6e,0x6e,0x6f,0x00,0x6b,0x6b,0x6c,0x00,0x68,0x68,0x69,0x00,
+		0x64,0x64,0x65,0x00,0x5f,0x5f,0x60,0x00,0x58,0x58,0x59,0x00,0x51,0x52,0x52,0x00,0x4c,0x4c,0x4c,0x00,0x45,0x46,0x46,0x00,
+		0x42,0x42,0x43,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x41,0x00,0x42,0x42,0x43,0x00,0x46,0x46,0x47,0x00,0x4c,0x4c,0x4d,0x00,
+		0x53,0x54,0x54,0x00,0x59,0x5a,0x5a,0x00,0x61,0x61,0x61,0x00,0x66,0x66,0x66,0x00,0x6a,0x69,0x69,0x00,0x6d,0x6d,0x6d,0x00,
+		0x70,0x6f,0x6f,0x00,0x72,0x72,0x71,0x00,0x73,0x73,0x71,0x00,0x73,0x73,0x72,0x00,0x73,0x72,0x71,0x00,0x73,0x73,0x70,0x00,
+		0x73,0x71,0x6e,0x00,0x71,0x70,0x6d,0x00,0x70,0x6e,0x6a,0x00,0x6f,0x6d,0x68,0x00,0x6e,0x6d,0x67,0x00,0x6d,0x6b,0x65,0x00,
+		0x6d,0x6b,0x63,0x00,0x6e,0x6c,0x63,0x00,0x70,0x6d,0x64,0x00,0x73,0x6f,0x65,0x00,0x75,0x72,0x66,0x00,0x79,0x74,0x68,0x00,
+		0x7c,0x77,0x6a,0x00,0x7e,0x79,0x6a,0x00,0x7a,0x74,0x64,0x00,0x73,0x6c,0x5b,0x00,0x71,0x6a,0x56,0x00,0x70,0x69,0x55,0x00,
+		0x72,0x6a,0x55,0x00,0x73,0x6b,0x55,0x00,0x73,0x6b,0x55,0x00,0x72,0x6b,0x53,0x00,0x72,0x69,0x53,0x00,0x72,0x6a,0x52,0x00,
+		0x71,0x69,0x51,0x00,0x70,0x68,0x50,0x00,0x70,0x67,0x50,0x00,0x6f,0x66,0x4e,0x00,0x6f,0x67,0x4e,0x00,0x6e,0x66,0x4d,0x00,
+		0x6e,0x66,0x4d,0x00,0x6f,0x66,0x4d,0x00,0x6f,0x66,0x4d,0x00,0x6f,0x66,0x4d,0x00,0x71,0x67,0x4e,0x00,0x71,0x67,0x4e,0x00,
+		0x71,0x68,0x4d,0x00,0x71,0x68,0x4d,0x00,0x72,0x68,0x4d,0x00,0x72,0x69,0x4d,0x00,0x72,0x68,0x4d,0x00,0x72,0x68,0x4c,0x00,
+		0x73,0x69,0x4d,0x00,0x73,0x69,0x4d,0x00,0x73,0x69,0x4d,0x00,0x73,0x69,0x4d,0x00,0x73,0x69,0x4d,0x00,0x72,0x68,0x4c,0x00,
+		0x72,0x68,0x4c,0x00,0x72,0x67,0x4c,0x00,0x72,0x68,0x4c,0x00,0x70,0x66,0x4b,0x00,0x6f,0x66,0x4a,0x00,0x6e,0x64,0x49,0x00,
+		0x6a,0x61,0x46,0x00,0x65,0x5c,0x41,0x00,0x5f,0x56,0x3d,0x00,0x57,0x4e,0x34,0x00,0x51,0x48,0x2e,0x00,0x48,0x3f,0x25,0x00,
+		0x40,0x37,0x1e,0x00,0x38,0x2f,0x16,0x00,0x32,0x28,0x10,0x00,0x2c,0x23,0x0a,0x00,0x29,0x20,0x07,0x00,0x26,0x1d,0x03,0x00,
+		0x25,0x1b,0x02,0x00,0x24,0x1b,0x01,0x00,0x24,0x1c,0x00,0x00,0x24,0x1b,0x00,0x00,0x25,0x1c,0x00,0x00,0x26,0x1c,0x00,0x00,
+		0x26,0x1c,0x00,0x00,0x27,0x1d,0x00,0x00,0x27,0x1d,0x00,0x00,0x28,0x1e,0x00,0x00,0x28,0x1d,0x00,0x00,0x28,0x1e,0x00,0x00,
+		0x27,0x1e,0x00,0x00,0x27,0x1e,0x00,0x00,0x27,0x1d,0x00,0x00,0x27,0x1e,0x00,0x00,0x26,0x1c,0x00,0x00,0x26,0x1d,0x00,0x00,
+		0x25,0x1c,0x00,0x00,0x24,0x1b,0x00,0x00,0x23,0x1a,0x00,0x00,0x22,0x19,0x00,0x00,0x20,0x18,0x00,0x00,0x1f,0x17,0x00,0x00,
+		0x1d,0x15,0x00,0x00,0x1c,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x18,0x11,0x00,0x00,0x17,0x11,0x00,0x00,0x15,0x10,0x00,0x00,
+		0x13,0x0f,0x00,0x00,0x11,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,0x0c,0x08,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1a,0x1b,0x00,
+		0x14,0x13,0x14,0x00,0x0e,0x0c,0x0e,0x00,0x0b,0x09,0x0b,0x00,0x09,0x07,0x0a,0x00,0x07,0x04,0x08,0x00,0x08,0x04,0x09,0x00,
+		0x09,0x05,0x0a,0x00,0x0b,0x06,0x0d,0x00,0x0e,0x08,0x0e,0x00,0x10,0x09,0x10,0x00,0x12,0x0b,0x13,0x00,0x14,0x0c,0x16,0x00,
+		0x16,0x0d,0x19,0x00,0x1a,0x0f,0x1c,0x00,0x1d,0x12,0x21,0x00,0x21,0x14,0x24,0x00,0x24,0x16,0x27,0x00,0x27,0x17,0x2b,0x00,
+		0x2b,0x1a,0x2f,0x00,0x2f,0x1c,0x33,0x00,0x32,0x1d,0x37,0x00,0x36,0x20,0x3b,0x00,0x38,0x21,0x3e,0x00,0x3d,0x24,0x43,0x00,
+		0x3f,0x25,0x46,0x00,0x44,0x28,0x4a,0x00,0x48,0x2a,0x4f,0x00,0x4e,0x2e,0x54,0x00,0x52,0x33,0x5a,0x00,0x5a,0x39,0x61,0x00,
+		0x62,0x40,0x6a,0x00,0x6a,0x48,0x73,0x00,0x74,0x51,0x7c,0x00,0x7d,0x5a,0x86,0x00,0x87,0x63,0x8f,0x00,0x90,0x6b,0x98,0x00,
+		0x98,0x74,0xa1,0x00,0x9f,0x7c,0xa9,0x00,0xa4,0x82,0xae,0x00,0xa8,0x87,0xb3,0x00,0xae,0x8e,0xba,0x00,0xb1,0x92,0xbd,0x00,
+		0xb3,0x95,0xbf,0x00,0xb4,0x99,0xc1,0x00,0xb3,0x9a,0xc2,0x00,0xb3,0x9e,0xc3,0x00,0xb3,0xa1,0xc4,0x00,0xc5,0xb9,0xd3,0x00,
+		0xea,0xe7,0xef,0x00,0xfe,0xfe,0xfe,0x00,0xfe,0xef,0xfe,0x00,0xfe,0xc4,0xff,0x00,0xfc,0x9f,0xff,0x00,0xfb,0x9a,0xff,0x00,
+		0xf9,0x9d,0xff,0x00,0xf8,0x9c,0xff,0x00,0xf7,0x9a,0xfe,0x00,0xf5,0x98,0xfe,0x00,0xf4,0x96,0xfd,0x00,0xf2,0x94,0xfc,0x00,
+		0xf1,0x92,0xfc,0x00,0xef,0x8f,0xfc,0x00,0xed,0x8d,0xfb,0x00,0xeb,0x87,0xfa,0x00,0xec,0x90,0xfb,0x00,0xff,0xee,0xff,0x00,
+		0xc9,0xff,0xf1,0x00,0x5b,0xf3,0xd4,0x00,0x5f,0xf3,0xd4,0x00,0x60,0xf2,0xd4,0x00,0x60,0xf2,0xd4,0x00,0x60,0xf2,0xd3,0x00,
+		0x5f,0xf1,0xd2,0x00,0x5e,0xf1,0xd1,0x00,0x5e,0xf1,0xd0,0x00,0x5c,0xf0,0xcf,0x00,0x5b,0xf0,0xce,0x00,0x52,0xee,0xcb,0x00,
+		0x58,0xef,0xcc,0x00,0x91,0xf5,0xdd,0x00,0xe0,0xfc,0xf5,0x00,0xff,0xff,0xff,0x00,0xe0,0xeb,0xe7,0x00,0xad,0xc8,0xbf,0x00,
+		0x92,0xb5,0xa9,0x00,0x93,0xb2,0xa7,0x00,0x92,0xb0,0xa5,0x00,0x90,0xab,0xa2,0x00,0x8f,0xa8,0x9f,0x00,0x8c,0xa3,0x9b,0x00,
+		0x89,0x9d,0x96,0x00,0x84,0x96,0x8f,0x00,0x7e,0x8e,0x88,0x00,0x77,0x86,0x80,0x00,0x6f,0x7b,0x76,0x00,0x67,0x72,0x6e,0x00,
+		0x5d,0x66,0x63,0x00,0x54,0x5c,0x59,0x00,0x4c,0x53,0x50,0x00,0x45,0x4b,0x49,0x00,0x41,0x46,0x44,0x00,0x3e,0x41,0x40,0x00,
+		0x43,0x47,0x46,0x00,0x4f,0x52,0x51,0x00,0x59,0x5c,0x5b,0x00,0x5c,0x5e,0x5e,0x00,0x60,0x61,0x61,0x00,0x62,0x62,0x62,0x00,
+		0x64,0x65,0x65,0x00,0x65,0x66,0x66,0x00,0x66,0x67,0x67,0x00,0x67,0x67,0x68,0x00,0x67,0x67,0x67,0x00,0x66,0x67,0x67,0x00,
+		0x67,0x67,0x67,0x00,0x65,0x66,0x66,0x00,0x65,0x66,0x67,0x00,0x64,0x65,0x65,0x00,0x64,0x64,0x65,0x00,0x63,0x63,0x64,0x00,
+		0x62,0x62,0x63,0x00,0x62,0x62,0x62,0x00,0x62,0x62,0x62,0x00,0x62,0x62,0x62,0x00,0x62,0x62,0x62,0x00,0x62,0x62,0x62,0x00,
+		0x62,0x62,0x63,0x00,0x63,0x63,0x64,0x00,0x63,0x63,0x64,0x00,0x63,0x63,0x64,0x00,0x63,0x63,0x64,0x00,0x63,0x63,0x64,0x00,
+		0x62,0x62,0x62,0x00,0x60,0x60,0x61,0x00,0x5e,0x5f,0x5f,0x00,0x5c,0x5c,0x5c,0x00,0x58,0x58,0x59,0x00,0x54,0x54,0x54,0x00,
+		0x4e,0x4f,0x4f,0x00,0x49,0x49,0x4a,0x00,0x44,0x44,0x45,0x00,0x40,0x40,0x40,0x00,0x3c,0x3c,0x3d,0x00,0x3a,0x3b,0x3b,0x00,
+		0x3a,0x3a,0x3b,0x00,0x3c,0x3c,0x3c,0x00,0x40,0x40,0x40,0x00,0x44,0x44,0x44,0x00,0x49,0x49,0x49,0x00,0x4f,0x4f,0x4f,0x00,
+		0x54,0x54,0x55,0x00,0x59,0x59,0x59,0x00,0x5c,0x5c,0x5c,0x00,0x5f,0x5f,0x5e,0x00,0x62,0x62,0x61,0x00,0x62,0x62,0x62,0x00,
+		0x64,0x64,0x62,0x00,0x65,0x64,0x62,0x00,0x64,0x63,0x62,0x00,0x64,0x63,0x62,0x00,0x63,0x62,0x60,0x00,0x62,0x62,0x5e,0x00,
+		0x62,0x60,0x5c,0x00,0x60,0x5f,0x5a,0x00,0x5f,0x5d,0x58,0x00,0x5f,0x5c,0x57,0x00,0x5f,0x5c,0x57,0x00,0x60,0x5c,0x56,0x00,
+		0x61,0x5e,0x56,0x00,0x63,0x61,0x57,0x00,0x67,0x62,0x58,0x00,0x69,0x65,0x59,0x00,0x66,0x62,0x56,0x00,0x62,0x5c,0x4e,0x00,
+		0x5c,0x57,0x47,0x00,0x5c,0x56,0x45,0x00,0x5d,0x57,0x45,0x00,0x5e,0x57,0x44,0x00,0x5f,0x58,0x45,0x00,0x60,0x59,0x45,0x00,
+		0x60,0x59,0x45,0x00,0x61,0x59,0x45,0x00,0x60,0x58,0x44,0x00,0x60,0x59,0x43,0x00,0x5f,0x58,0x42,0x00,0x5e,0x57,0x42,0x00,
+		0x5e,0x56,0x41,0x00,0x5d,0x55,0x40,0x00,0x5e,0x56,0x40,0x00,0x5d,0x55,0x3f,0x00,0x5c,0x54,0x3e,0x00,0x5c,0x54,0x3e,0x00,
+		0x5d,0x55,0x3e,0x00,0x5d,0x55,0x3e,0x00,0x5e,0x56,0x3f,0x00,0x5f,0x57,0x3f,0x00,0x5f,0x57,0x3f,0x00,0x60,0x57,0x3f,0x00,
+		0x60,0x57,0x3f,0x00,0x5f,0x56,0x3e,0x00,0x60,0x58,0x3e,0x00,0x61,0x58,0x3e,0x00,0x61,0x58,0x3e,0x00,0x61,0x58,0x3e,0x00,
+		0x60,0x57,0x3e,0x00,0x62,0x59,0x3e,0x00,0x62,0x59,0x3e,0x00,0x61,0x58,0x3e,0x00,0x61,0x58,0x3e,0x00,0x60,0x57,0x3e,0x00,
+		0x60,0x57,0x3e,0x00,0x60,0x57,0x3d,0x00,0x5e,0x55,0x3d,0x00,0x5c,0x53,0x3b,0x00,0x58,0x50,0x37,0x00,0x55,0x4c,0x35,0x00,
+		0x50,0x47,0x30,0x00,0x4b,0x42,0x2a,0x00,0x44,0x3b,0x24,0x00,0x3e,0x35,0x1e,0x00,0x37,0x2e,0x18,0x00,0x30,0x28,0x11,0x00,
+		0x2b,0x22,0x0c,0x00,0x27,0x1f,0x08,0x00,0x23,0x1c,0x04,0x00,0x23,0x1a,0x03,0x00,0x21,0x19,0x01,0x00,0x21,0x19,0x01,0x00,
+		0x21,0x18,0x00,0x00,0x21,0x18,0x00,0x00,0x22,0x19,0x00,0x00,0x22,0x19,0x00,0x00,0x23,0x1a,0x00,0x00,0x24,0x1a,0x00,0x00,
+		0x24,0x1a,0x00,0x00,0x24,0x1b,0x00,0x00,0x25,0x1b,0x00,0x00,0x25,0x1c,0x00,0x00,0x24,0x1b,0x00,0x00,0x25,0x1b,0x00,0x00,
+		0x24,0x1b,0x00,0x00,0x24,0x1b,0x00,0x00,0x23,0x1a,0x00,0x00,0x23,0x1a,0x00,0x00,0x22,0x1a,0x00,0x00,0x21,0x18,0x00,0x00,
+		0x20,0x18,0x00,0x00,0x1f,0x17,0x00,0x00,0x1e,0x16,0x00,0x00,0x1c,0x15,0x00,0x00,0x1b,0x14,0x00,0x00,0x19,0x13,0x00,0x00,
+		0x18,0x12,0x00,0x00,0x17,0x12,0x00,0x00,0x15,0x10,0x00,0x00,0x13,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x22,0x23,0x00,0x21,0x20,0x21,0x00,
+		0x1b,0x1a,0x1b,0x00,0x16,0x15,0x17,0x00,0x12,0x0f,0x12,0x00,0x0d,0x0b,0x0e,0x00,0x0c,0x08,0x0d,0x00,0x0c,0x07,0x0d,0x00,
+		0x0d,0x07,0x0e,0x00,0x0f,0x09,0x10,0x00,0x10,0x0a,0x12,0x00,0x13,0x0c,0x15,0x00,0x16,0x0d,0x18,0x00,0x18,0x0f,0x1b,0x00,
+		0x1c,0x11,0x1f,0x00,0x1f,0x13,0x23,0x00,0x23,0x15,0x25,0x00,0x26,0x17,0x2a,0x00,0x2a,0x19,0x2e,0x00,0x2b,0x1a,0x30,0x00,
+		0x30,0x1d,0x35,0x00,0x33,0x1e,0x38,0x00,0x37,0x21,0x3c,0x00,0x3a,0x22,0x40,0x00,0x3e,0x25,0x44,0x00,0x41,0x27,0x47,0x00,
+		0x47,0x2b,0x4d,0x00,0x4a,0x2d,0x4f,0x00,0x4f,0x31,0x55,0x00,0x55,0x36,0x5c,0x00,0x5c,0x3c,0x62,0x00,0x65,0x44,0x6c,0x00,
+		0x6d,0x4b,0x75,0x00,0x77,0x54,0x7e,0x00,0x7f,0x5d,0x87,0x00,0x87,0x65,0x8f,0x00,0x8f,0x6d,0x98,0x00,0x97,0x75,0xa0,0x00,
+		0x9d,0x7c,0xa6,0x00,0xa2,0x82,0xac,0x00,0xa8,0x89,0xb3,0x00,0xa9,0x8c,0xb5,0x00,0xae,0x92,0xbb,0x00,0xaf,0x94,0xbc,0x00,
+		0xb1,0x99,0xbf,0x00,0xb1,0x9b,0xc0,0x00,0xb1,0xa0,0xc1,0x00,0xb0,0xa1,0xc2,0x00,0xb2,0xa8,0xc5,0x00,0xce,0xca,0xdb,0x00,
+		0xf0,0xef,0xf4,0x00,0xff,0xff,0xff,0x00,0xff,0xe6,0xff,0x00,0xfd,0xb8,0xff,0x00,0xfb,0x9b,0xff,0x00,0xfa,0x9b,0xff,0x00,
+		0xf8,0x9d,0xff,0x00,0xf7,0x9a,0xfe,0x00,0xf6,0x99,0xfe,0x00,0xf4,0x97,0xfd,0x00,0xf3,0x95,0xfd,0x00,0xf1,0x93,0xfc,0x00,
+		0xf0,0x91,0xfc,0x00,0xee,0x8b,0xfb,0x00,0xee,0x94,0xfb,0x00,0xff,0xee,0xff,0x00,0xca,0xff,0xf1,0x00,0x5c,0xf3,0xd5,0x00,
+		0x60,0xf3,0xd5,0x00,0x61,0xf3,0xd5,0x00,0x60,0xf2,0xd4,0x00,0x60,0xf2,0xd3,0x00,0x60,0xf2,0xd3,0x00,0x5f,0xf1,0xd2,0x00,
+		0x5f,0xf1,0xd1,0x00,0x57,0xf0,0xcf,0x00,0x54,0xef,0xce,0x00,0x7f,0xf3,0xd9,0x00,0xd1,0xfb,0xf1,0x00,0xff,0xff,0xff,0x00,
+		0xec,0xf3,0xf1,0x00,0xb9,0xd2,0xc9,0x00,0x94,0xb7,0xab,0x00,0x92,0xb4,0xa9,0x00,0x91,0xb2,0xa7,0x00,0x90,0xae,0xa4,0x00,
+		0x8e,0xaa,0xa0,0x00,0x8c,0xa5,0x9c,0x00,0x8a,0xa1,0x99,0x00,0x84,0x99,0x92,0x00,0x80,0x93,0x8d,0x00,0x7b,0x8c,0x85,0x00,
+		0x73,0x82,0x7c,0x00,0x6a,0x77,0x73,0x00,0x61,0x6d,0x69,0x00,0x58,0x62,0x5f,0x00,0x4e,0x57,0x54,0x00,0x45,0x4d,0x4a,0x00,
+		0x3d,0x43,0x41,0x00,0x37,0x3c,0x3a,0x00,0x34,0x38,0x37,0x00,0x3a,0x3d,0x3c,0x00,0x45,0x48,0x47,0x00,0x4c,0x4e,0x4e,0x00,
+		0x4e,0x50,0x4f,0x00,0x50,0x51,0x51,0x00,0x51,0x52,0x52,0x00,0x54,0x55,0x55,0x00,0x55,0x56,0x56,0x00,0x57,0x57,0x57,0x00,
+		0x57,0x58,0x58,0x00,0x58,0x58,0x58,0x00,0x57,0x58,0x58,0x00,0x58,0x58,0x58,0x00,0x57,0x58,0x58,0x00,0x58,0x58,0x58,0x00,
+		0x57,0x57,0x58,0x00,0x57,0x57,0x57,0x00,0x56,0x56,0x57,0x00,0x55,0x55,0x56,0x00,0x55,0x55,0x56,0x00,0x54,0x55,0x55,0x00,
+		0x54,0x55,0x55,0x00,0x54,0x55,0x55,0x00,0x54,0x55,0x55,0x00,0x55,0x56,0x56,0x00,0x55,0x56,0x56,0x00,0x55,0x56,0x56,0x00,
+		0x55,0x56,0x56,0x00,0x55,0x56,0x56,0x00,0x55,0x56,0x56,0x00,0x55,0x56,0x56,0x00,0x54,0x54,0x55,0x00,0x54,0x54,0x54,0x00,
+		0x52,0x52,0x52,0x00,0x50,0x50,0x51,0x00,0x4d,0x4d,0x4e,0x00,0x49,0x49,0x4a,0x00,0x45,0x45,0x45,0x00,0x40,0x41,0x41,0x00,
+		0x3d,0x3d,0x3d,0x00,0x3a,0x3a,0x3a,0x00,0x37,0x37,0x38,0x00,0x35,0x36,0x36,0x00,0x35,0x35,0x36,0x00,0x36,0x36,0x37,0x00,
+		0x3a,0x3a,0x3a,0x00,0x3d,0x3d,0x3e,0x00,0x40,0x40,0x40,0x00,0x45,0x45,0x45,0x00,0x49,0x49,0x49,0x00,0x4c,0x4c,0x4c,0x00,
+		0x4f,0x4f,0x4f,0x00,0x51,0x51,0x51,0x00,0xa3,0xa3,0xa3,0x00,0x54,0x54,0x53,0x00,0x55,0x54,0x53,0x00,0x55,0x55,0x54,0x00,
+		0x56,0x55,0x53,0x00,0x56,0x55,0x53,0x00,0x55,0x54,0x51,0x00,0x53,0x52,0x4f,0x00,0x53,0x51,0x4e,0x00,0x52,0x51,0x4c,0x00,
+		0x51,0x4f,0x4b,0x00,0x51,0x4f,0x4a,0x00,0x51,0x4f,0x49,0x00,0x52,0x50,0x48,0x00,0x53,0x51,0x49,0x00,0x56,0x52,0x4a,0x00,
+		0x55,0x52,0x48,0x00,0x50,0x4c,0x41,0x00,0x48,0x45,0x37,0x00,0x45,0x41,0x33,0x00,0x47,0x41,0x32,0x00,0x49,0x43,0x33,0x00,
+		0x4a,0x44,0x34,0x00,0x4c,0x46,0x35,0x00,0x4c,0x46,0x35,0x00,0x4d,0x47,0x34,0x00,0x4d,0x46,0x34,0x00,0x4d,0x47,0x34,0x00,
+		0x4d,0x47,0x34,0x00,0x4d,0x46,0x33,0x00,0x4d,0x46,0x33,0x00,0x4c,0x45,0x32,0x00,0x4b,0x45,0x31,0x00,0x4a,0x44,0x30,0x00,
+		0x4a,0x43,0x30,0x00,0x4a,0x43,0x2f,0x00,0x49,0x43,0x2e,0x00,0x49,0x42,0x2e,0x00,0x49,0x43,0x2e,0x00,0x4b,0x44,0x2f,0x00,
+		0x4b,0x44,0x2f,0x00,0x4c,0x44,0x2f,0x00,0x4c,0x44,0x2f,0x00,0x4d,0x45,0x2f,0x00,0x4e,0x46,0x30,0x00,0x4e,0x46,0x2f,0x00,
+		0x4e,0x46,0x2f,0x00,0x4d,0x46,0x2f,0x00,0x4f,0x47,0x2f,0x00,0x4f,0x47,0x2f,0x00,0x4e,0x46,0x2f,0x00,0x50,0x47,0x2f,0x00,
+		0x50,0x47,0x2f,0x00,0x50,0x48,0x2f,0x00,0x4f,0x46,0x2f,0x00,0x4e,0x45,0x2e,0x00,0x4d,0x45,0x2e,0x00,0x4d,0x45,0x2e,0x00,
+		0x4c,0x43,0x2d,0x00,0x4b,0x42,0x2b,0x00,0x48,0x40,0x2a,0x00,0x46,0x3f,0x28,0x00,0x40,0x39,0x23,0x00,0x3c,0x34,0x1f,0x00,
+		0x37,0x30,0x1a,0x00,0x32,0x2a,0x15,0x00,0x2d,0x26,0x11,0x00,0x29,0x22,0x0c,0x00,0x24,0x1e,0x08,0x00,0x21,0x1b,0x05,0x00,
+		0x21,0x19,0x04,0x00,0x1f,0x18,0x02,0x00,0x1e,0x16,0x01,0x00,0x1e,0x16,0x01,0x00,0x1e,0x17,0x00,0x00,0x1e,0x16,0x00,0x00,
+		0x1f,0x17,0x00,0x00,0x1f,0x17,0x00,0x00,0x20,0x18,0x00,0x00,0x20,0x18,0x00,0x00,0x21,0x18,0x00,0x00,0x21,0x18,0x00,0x00,
+		0x21,0x18,0x00,0x00,0x22,0x19,0x00,0x00,0x22,0x19,0x00,0x00,0x22,0x19,0x00,0x00,0x21,0x19,0x00,0x00,0x21,0x18,0x00,0x00,
+		0x21,0x19,0x00,0x00,0x1f,0x18,0x00,0x00,0x1f,0x18,0x00,0x00,0x1e,0x17,0x00,0x00,0x1d,0x16,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x1b,0x14,0x00,0x00,0x1a,0x14,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x16,0x11,0x00,0x00,0x15,0x10,0x00,0x00,
+		0x13,0x0f,0x00,0x00,0x12,0x0e,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0d,0x09,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x23,0x00,0x23,0x22,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x23,0x25,0x00,
+		0x24,0x22,0x24,0x00,0x22,0x20,0x23,0x00,0x1d,0x1a,0x1e,0x00,0x17,0x14,0x18,0x00,0x13,0x0f,0x15,0x00,0x11,0x0b,0x11,0x00,
+		0x11,0x0b,0x12,0x00,0x12,0x0c,0x14,0x00,0x14,0x0c,0x16,0x00,0x17,0x0e,0x19,0x00,0x1a,0x10,0x1d,0x00,0x1e,0x12,0x21,0x00,
+		0x20,0x14,0x23,0x00,0x24,0x16,0x27,0x00,0x27,0x18,0x2c,0x00,0x29,0x19,0x2d,0x00,0x2d,0x1b,0x31,0x00,0x30,0x1d,0x35,0x00,
+		0x34,0x1f,0x39,0x00,0x37,0x21,0x3c,0x00,0x3c,0x24,0x41,0x00,0x3f,0x26,0x44,0x00,0x41,0x28,0x47,0x00,0x46,0x2b,0x4c,0x00,
+		0x4d,0x2f,0x52,0x00,0x51,0x33,0x56,0x00,0x58,0x3a,0x5f,0x00,0x5e,0x3e,0x64,0x00,0x66,0x46,0x6c,0x00,0x6e,0x4d,0x75,0x00,
+		0x77,0x55,0x7d,0x00,0x7c,0x5c,0x84,0x00,0x87,0x65,0x8f,0x00,0x8e,0x6d,0x97,0x00,0x95,0x75,0x9e,0x00,0x9a,0x7c,0xa4,0x00,
+		0xa0,0x81,0xaa,0x00,0xa4,0x87,0xaf,0x00,0xa9,0x8d,0xb5,0x00,0xac,0x92,0xb8,0x00,0xae,0x97,0xbc,0x00,0xae,0x9a,0xbd,0x00,
+		0xb0,0x9e,0xc0,0x00,0xaf,0xa1,0xc1,0x00,0xaf,0xa5,0xc2,0x00,0xad,0xa7,0xc2,0x00,0xb4,0xb3,0xc9,0x00,0xd7,0xd8,0xe2,0x00,
+		0xf8,0xf9,0xfa,0x00,0xff,0xfd,0xff,0x00,0xfe,0xdb,0xff,0x00,0xfc,0xad,0xff,0x00,0xfb,0x99,0xff,0x00,0xf9,0x9b,0xff,0x00,
+		0xf8,0x9c,0xff,0x00,0xf6,0x9a,0xfe,0x00,0xf5,0x98,0xfe,0x00,0xf3,0x96,0xfd,0x00,0xf2,0x94,0xfd,0x00,0xf1,0x8e,0xfc,0x00,
+		0xf1,0x96,0xfd,0x00,0xff,0xef,0xff,0x00,0xca,0xff,0xf2,0x00,0x5d,0xf4,0xd7,0x00,0x62,0xf4,0xd7,0x00,0x62,0xf3,0xd6,0x00,
+		0x61,0xf3,0xd6,0x00,0x61,0xf2,0xd5,0x00,0x61,0xf2,0xd4,0x00,0x5b,0xf2,0xd2,0x00,0x54,0xf1,0xcf,0x00,0x6f,0xf2,0xd6,0x00,
+		0xbc,0xf9,0xeb,0x00,0xf9,0xff,0xfd,0x00,0xf6,0xf9,0xf8,0x00,0xc6,0xda,0xd4,0x00,0x9b,0xbe,0xb3,0x00,0x91,0xb6,0xaa,0x00,
+		0x91,0xb3,0xa8,0x00,0x90,0xb1,0xa6,0x00,0x8f,0xad,0xa3,0x00,0x8d,0xa9,0x9f,0x00,0x8a,0xa3,0x9b,0x00,0x86,0x9d,0x95,0x00,
+		0x81,0x97,0x8f,0x00,0x7b,0x8f,0x88,0x00,0x76,0x87,0x81,0x00,0x6e,0x7e,0x78,0x00,0x66,0x74,0x6f,0x00,0x5d,0x6a,0x65,0x00,
+		0x53,0x5e,0x5a,0x00,0x4b,0x54,0x50,0x00,0x40,0x48,0x46,0x00,0x38,0x3f,0x3c,0x00,0x30,0x36,0x34,0x00,0x2f,0x34,0x32,0x00,
+		0x34,0x37,0x36,0x00,0x3f,0x42,0x40,0x00,0x42,0x45,0x44,0x00,0x42,0x44,0x43,0x00,0x42,0x44,0x44,0x00,0x6a,0x6b,0x6b,0x00,
+		0xce,0xce,0xce,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xb7,0xb7,0xb8,0x00,0x4c,0x4c,0x4d,0x00,
+		0x4c,0x4c,0x4c,0x00,0x4c,0x4c,0x4d,0x00,0x4c,0x4d,0x4d,0x00,0x4b,0x4b,0x4c,0x00,0x4b,0x4b,0x4b,0x00,0x4b,0x4b,0x4b,0x00,
+		0x4a,0x4a,0x4b,0x00,0x4a,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,0x48,0x48,0x49,0x00,0x48,0x48,0x49,0x00,0x48,0x48,0x49,0x00,
+		0x49,0x49,0x4a,0x00,0x49,0x49,0x4a,0x00,0x49,0x49,0x4a,0x00,0x4a,0x4a,0x4b,0x00,0x4a,0x4a,0x4b,0x00,0x4a,0x4a,0x4b,0x00,
+		0x4a,0x4a,0x4a,0x00,0x4a,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,0x48,0x48,0x49,0x00,0x47,0x47,0x48,0x00,0x45,0x45,0x45,0x00,
+		0x43,0x43,0x43,0x00,0x40,0x40,0x40,0x00,0x3d,0x3d,0x3d,0x00,0x3a,0x3a,0x3a,0x00,0x37,0x37,0x37,0x00,0x34,0x34,0x35,0x00,
+		0x32,0x32,0x33,0x00,0x31,0x31,0x32,0x00,0x32,0x32,0x32,0x00,0x32,0x33,0x33,0x00,0x34,0x34,0x34,0x00,0x36,0x37,0x37,0x00,
+		0x3a,0x3a,0x3a,0x00,0x3c,0x3c,0x3d,0x00,0x40,0x40,0x40,0x00,0x41,0x41,0x41,0x00,0x45,0x45,0x44,0x00,0xce,0xce,0xce,0x00,
+		0xce,0xce,0xce,0x00,0x47,0x47,0x46,0x00,0x48,0x48,0x47,0x00,0xff,0xff,0xff,0x00,0x9d,0x9d,0x9c,0x00,0x48,0x47,0x46,0x00,
+		0x47,0x47,0x45,0x00,0x47,0x46,0x44,0x00,0x46,0x46,0x43,0x00,0x46,0x45,0x41,0x00,0x45,0x44,0x40,0x00,0x45,0x43,0x3e,0x00,
+		0x45,0x44,0x3e,0x00,0x45,0x44,0x3d,0x00,0x47,0x45,0x3d,0x00,0x43,0x40,0x38,0x00,0x3a,0x37,0x2d,0x00,0x35,0x31,0x26,0x00,
+		0x33,0x2f,0x23,0x00,0x35,0x30,0x23,0x00,0x37,0x33,0x25,0x00,0x38,0x33,0x25,0x00,0x3a,0x35,0x27,0x00,0x3b,0x35,0x26,0x00,
+		0x3c,0x36,0x27,0x00,0x3c,0x37,0x26,0x00,0x3c,0x37,0x26,0x00,0x3d,0x37,0x26,0x00,0x3c,0x36,0x25,0x00,0x3d,0x37,0x26,0x00,
+		0x3b,0x36,0x24,0x00,0x3c,0x36,0x24,0x00,0x3b,0x35,0x23,0x00,0x3a,0x34,0x22,0x00,0x3a,0x34,0x22,0x00,0x3a,0x33,0x22,0x00,
+		0x3a,0x33,0x22,0x00,0x3a,0x34,0x21,0x00,0x3a,0x34,0x21,0x00,0x3a,0x34,0x21,0x00,0x3b,0x35,0x22,0x00,0x3c,0x35,0x22,0x00,
+		0x3c,0x35,0x22,0x00,0x3c,0x35,0x22,0x00,0x3d,0x36,0x22,0x00,0x3d,0x36,0x22,0x00,0x3e,0x36,0x22,0x00,0x3e,0x37,0x22,0x00,
+		0x3f,0x37,0x22,0x00,0x3f,0x37,0x22,0x00,0x3f,0x37,0x22,0x00,0x40,0x38,0x22,0x00,0x3f,0x38,0x22,0x00,0x3f,0x38,0x22,0x00,
+		0x40,0x38,0x22,0x00,0x3f,0x38,0x22,0x00,0x40,0x38,0x22,0x00,0x3d,0x36,0x21,0x00,0x3e,0x36,0x21,0x00,0x3d,0x36,0x20,0x00,
+		0x3b,0x33,0x1e,0x00,0x37,0x2f,0x1b,0x00,0x34,0x2d,0x19,0x00,0x31,0x2a,0x16,0x00,0x2d,0x26,0x13,0x00,0x29,0x22,0x0e,0x00,
+		0x26,0x1f,0x0b,0x00,0x22,0x1c,0x08,0x00,0x1f,0x18,0x05,0x00,0x1f,0x18,0x04,0x00,0x1d,0x16,0x02,0x00,0x1b,0x15,0x01,0x00,
+		0x1a,0x14,0x00,0x00,0x1b,0x15,0x00,0x00,0x1b,0x15,0x00,0x00,0x1b,0x15,0x00,0x00,0x1c,0x15,0x00,0x00,0x1c,0x14,0x00,0x00,
+		0x1d,0x15,0x00,0x00,0x1d,0x15,0x00,0x00,0x1d,0x15,0x00,0x00,0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,
+		0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,0x1e,0x16,0x00,0x00,0x1c,0x15,0x00,0x00,
+		0x1c,0x15,0x00,0x00,0x1b,0x14,0x00,0x00,0x1a,0x14,0x00,0x00,0x19,0x13,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x12,0x00,0x00,
+		0x17,0x12,0x00,0x00,0x15,0x10,0x00,0x00,0x14,0x0f,0x00,0x00,0x13,0x0e,0x00,0x00,0x11,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x0f,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x08,0x05,0x00,0x00,0x07,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,
+		0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x27,0x25,0x28,0x00,0x28,0x26,0x29,0x00,
+		0x28,0x25,0x28,0x00,0x29,0x25,0x29,0x00,0x26,0x24,0x28,0x00,0x22,0x1d,0x23,0x00,0x1b,0x16,0x1d,0x00,0x19,0x13,0x1a,0x00,
+		0x18,0x11,0x1b,0x00,0x18,0x10,0x1a,0x00,0x19,0x10,0x1b,0x00,0x1b,0x12,0x1e,0x00,0x1f,0x14,0x22,0x00,0x22,0x15,0x25,0x00,
+		0x25,0x18,0x29,0x00,0x29,0x1a,0x2c,0x00,0x2b,0x1a,0x2e,0x00,0x2f,0x1d,0x33,0x00,0x33,0x1e,0x36,0x00,0x36,0x21,0x3a,0x00,
+		0x38,0x22,0x3d,0x00,0x3c,0x25,0x41,0x00,0x3f,0x27,0x44,0x00,0x44,0x2b,0x4a,0x00,0x48,0x2d,0x4d,0x00,0x4c,0x30,0x51,0x00,
+		0x52,0x35,0x58,0x00,0x59,0x3b,0x5e,0x00,0x5f,0x41,0x66,0x00,0x64,0x46,0x6b,0x00,0x6e,0x4e,0x75,0x00,0x75,0x56,0x7c,0x00,
+		0x7d,0x5d,0x83,0x00,0x84,0x65,0x8c,0x00,0x8a,0x6b,0x92,0x00,0x91,0x73,0x9a,0x00,0x97,0x7a,0xa0,0x00,0x9c,0x80,0xa7,0x00,
+		0xa0,0x86,0xac,0x00,0xa3,0x8b,0xb0,0x00,0xa6,0x90,0xb4,0x00,0xa9,0x96,0xb8,0x00,0xab,0x9a,0xba,0x00,0xad,0x9f,0xbe,0x00,
+		0xac,0xa2,0xbe,0x00,0xac,0xa6,0xc0,0x00,0xac,0xa9,0xc1,0x00,0xaa,0xac,0xc1,0x00,0xb7,0xbc,0xcc,0x00,0xdf,0xe2,0xe8,0x00,
+		0xfd,0xfd,0xfe,0x00,0xff,0xf8,0xff,0x00,0xfd,0xcd,0xff,0x00,0xfb,0xa5,0xff,0x00,0xfa,0x98,0xff,0x00,0xf8,0x9c,0xfe,0x00,
+		0xf7,0x9c,0xfe,0x00,0xf6,0x99,0xfe,0x00,0xf4,0x97,0xfd,0x00,0xf2,0x91,0xfc,0x00,0xf3,0x9a,0xfc,0x00,0xff,0xef,0xff,0x00,
+		0xca,0xff,0xf2,0x00,0x5e,0xf3,0xd7,0x00,0x62,0xf4,0xd8,0x00,0x63,0xf3,0xd8,0x00,0x63,0xf3,0xd7,0x00,0x61,0xf3,0xd6,0x00,
+		0x57,0xf2,0xd2,0x00,0x65,0xf2,0xd5,0x00,0xa7,0xf7,0xe7,0x00,0xef,0xfe,0xfa,0x00,0xfb,0xfc,0xfc,0x00,0xd6,0xe5,0xe1,0x00,
+		0xa2,0xc4,0xba,0x00,0x91,0xb7,0xac,0x00,0x90,0xb4,0xa8,0x00,0x90,0xb2,0xa7,0x00,0x8e,0xae,0xa4,0x00,0x8c,0xaa,0xa0,0x00,
+		0x8a,0xa6,0x9d,0x00,0x87,0xa0,0x98,0x00,0x82,0x9a,0x92,0x00,0x7d,0x94,0x8c,0x00,0x77,0x8b,0x84,0x00,0x71,0x83,0x7d,0x00,
+		0x69,0x79,0x74,0x00,0x61,0x6f,0x6b,0x00,0x57,0x64,0x60,0x00,0x4f,0x5a,0x57,0x00,0x45,0x4f,0x4c,0x00,0x3d,0x46,0x43,0x00,
+		0x33,0x3b,0x38,0x00,0x2d,0x34,0x31,0x00,0x2d,0x32,0x30,0x00,0x34,0x39,0x37,0x00,0x3b,0x3f,0x3e,0x00,0x3a,0x3e,0x3d,0x00,
+		0x3a,0x3c,0x3b,0x00,0x3a,0x3b,0x3a,0x00,0x6f,0x6f,0x6f,0x00,0xff,0xff,0xff,0x00,0xbd,0xbe,0xbe,0x00,0x4a,0x4b,0x4b,0x00,
+		0x3f,0x40,0x40,0x00,0x72,0x73,0x73,0x00,0xe5,0xe5,0xe5,0x00,0xd9,0xd9,0xd9,0x00,0x40,0x40,0x41,0x00,0x41,0x42,0x42,0x00,
+		0x40,0x40,0x41,0x00,0x40,0x40,0x41,0x00,0x40,0x41,0x41,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,
+		0x3f,0x3f,0x3f,0x00,0x3e,0x3e,0x3f,0x00,0x3e,0x3e,0x3f,0x00,0x3e,0x3e,0x3f,0x00,0x3f,0x3f,0x40,0x00,0x3f,0x3f,0x40,0x00,
+		0x3f,0x3f,0x40,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,0x40,0x40,0x40,0x00,
+		0x3f,0x3f,0x3f,0x00,0x3e,0x3e,0x3e,0x00,0x3d,0x3d,0x3e,0x00,0x3c,0x3c,0x3d,0x00,0x3a,0x3a,0x3a,0x00,0x38,0x39,0x39,0x00,
+		0x37,0x37,0x37,0x00,0x34,0x34,0x34,0x00,0x32,0x32,0x32,0x00,0x31,0x31,0x31,0x00,0x2f,0x2f,0x2f,0x00,0x2f,0x2f,0x2f,0x00,
+		0x2f,0x2f,0x2f,0x00,0x2f,0x2f,0x2f,0x00,0x2f,0x30,0x30,0x00,0x31,0x31,0x32,0x00,0x34,0x34,0x34,0x00,0x35,0x35,0x35,0x00,
+		0x37,0x37,0x37,0x00,0x39,0x39,0x39,0x00,0x3a,0x3a,0x3a,0x00,0xca,0xca,0xca,0x00,0xcb,0xcb,0xcb,0x00,0x3d,0x3d,0x3c,0x00,
+		0x3d,0x3d,0x3c,0x00,0x3e,0x3d,0x3c,0x00,0x3d,0x3c,0x3b,0x00,0x3d,0x3d,0x3b,0x00,0x3d,0x3c,0x3a,0x00,0x3d,0x3c,0x3a,0x00,
+		0x3c,0x3b,0x38,0x00,0x3c,0x3b,0x38,0x00,0x3b,0x3a,0x36,0x00,0x3b,0x3a,0x36,0x00,0x3c,0x3a,0x35,0x00,0x39,0x37,0x32,0x00,
+		0x2f,0x2d,0x26,0x00,0x25,0x22,0x1a,0x00,0x21,0x1e,0x15,0x00,0x22,0x1f,0x15,0x00,0x24,0x20,0x16,0x00,0x27,0x23,0x17,0x00,
+		0x28,0x24,0x18,0x00,0x2a,0x25,0x19,0x00,0x2b,0x26,0x19,0x00,0x2b,0x26,0x19,0x00,0x2d,0x28,0x1a,0x00,0x2d,0x28,0x1a,0x00,
+		0x2e,0x28,0x1a,0x00,0x2d,0x28,0x1a,0x00,0x2d,0x28,0x19,0x00,0x2d,0x28,0x19,0x00,0x2e,0x28,0x19,0x00,0x2d,0x27,0x18,0x00,
+		0x2c,0x26,0x17,0x00,0x2c,0x26,0x17,0x00,0x2c,0x26,0x17,0x00,0x2b,0x26,0x16,0x00,0x2b,0x26,0x16,0x00,0x2c,0x26,0x16,0x00,
+		0x2c,0x26,0x16,0x00,0x2c,0x26,0x16,0x00,0x2e,0x28,0x17,0x00,0x2e,0x27,0x17,0x00,0x2f,0x28,0x17,0x00,0x2f,0x29,0x17,0x00,
+		0x2f,0x29,0x17,0x00,0x30,0x29,0x17,0x00,0x30,0x29,0x17,0x00,0x30,0x29,0x17,0x00,0x30,0x2a,0x16,0x00,0x30,0x2a,0x16,0x00,
+		0x30,0x2a,0x16,0x00,0x31,0x2a,0x16,0x00,0x31,0x2a,0x16,0x00,0x31,0x2a,0x16,0x00,0x31,0x2a,0x16,0x00,0x31,0x2a,0x16,0x00,
+		0x31,0x2a,0x16,0x00,0x30,0x29,0x15,0x00,0x30,0x29,0x16,0x00,0x2e,0x28,0x15,0x00,0x2d,0x26,0x13,0x00,0x2b,0x24,0x12,0x00,
+		0x29,0x22,0x10,0x00,0x27,0x21,0x0e,0x00,0x25,0x1e,0x0c,0x00,0x21,0x1b,0x09,0x00,0x1f,0x19,0x07,0x00,0x1e,0x18,0x05,0x00,
+		0x1c,0x16,0x04,0x00,0x1b,0x14,0x02,0x00,0x19,0x13,0x01,0x00,0x19,0x13,0x01,0x00,0x19,0x13,0x00,0x00,0x19,0x13,0x00,0x00,
+		0x19,0x12,0x00,0x00,0x18,0x13,0x00,0x00,0x19,0x12,0x00,0x00,0x19,0x12,0x00,0x00,0x1a,0x13,0x00,0x00,0x1a,0x13,0x00,0x00,
+		0x1a,0x13,0x00,0x00,0x1b,0x14,0x00,0x00,0x1b,0x14,0x00,0x00,0x1b,0x14,0x00,0x00,0x1b,0x14,0x00,0x00,0x1b,0x14,0x00,0x00,
+		0x1b,0x14,0x00,0x00,0x1a,0x14,0x00,0x00,0x1b,0x14,0x00,0x00,0x1a,0x13,0x00,0x00,0x1a,0x13,0x00,0x00,0x19,0x12,0x00,0x00,
+		0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x16,0x11,0x00,0x00,0x15,0x10,0x00,0x00,0x14,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,
+		0x13,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x09,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,0x23,0x22,0x23,0x00,0x24,0x23,0x24,0x00,
+		0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x26,0x25,0x27,0x00,0x26,0x24,0x27,0x00,0x29,0x27,0x2a,0x00,0x2a,0x28,0x2b,0x00,
+		0x2b,0x28,0x2b,0x00,0x2d,0x2a,0x2e,0x00,0x2c,0x28,0x2d,0x00,0x28,0x25,0x2a,0x00,0x25,0x1f,0x26,0x00,0x21,0x19,0x22,0x00,
+		0x1d,0x15,0x1f,0x00,0x1d,0x14,0x1f,0x00,0x1d,0x13,0x20,0x00,0x20,0x15,0x23,0x00,0x23,0x16,0x26,0x00,0x26,0x18,0x29,0x00,
+		0x2a,0x1b,0x2d,0x00,0x2c,0x1b,0x30,0x00,0x30,0x1e,0x33,0x00,0x33,0x1f,0x36,0x00,0x37,0x22,0x3b,0x00,0x38,0x23,0x3d,0x00,
+		0x3d,0x26,0x41,0x00,0x40,0x28,0x45,0x00,0x45,0x2c,0x4a,0x00,0x48,0x2e,0x4d,0x00,0x4e,0x33,0x53,0x00,0x52,0x37,0x58,0x00,
+		0x57,0x3b,0x5c,0x00,0x5e,0x41,0x64,0x00,0x64,0x46,0x6a,0x00,0x6b,0x4d,0x72,0x00,0x72,0x54,0x79,0x00,0x79,0x5c,0x80,0x00,
+		0x80,0x64,0x89,0x00,0x87,0x6a,0x90,0x00,0x8c,0x71,0x96,0x00,0x92,0x77,0x9c,0x00,0x97,0x7e,0xa1,0x00,0x9c,0x84,0xa7,0x00,
+		0xa0,0x8b,0xad,0x00,0xa3,0x91,0xb1,0x00,0xa5,0x95,0xb4,0x00,0xa7,0x9b,0xb8,0x00,0xa9,0x9f,0xba,0x00,0xa9,0xa3,0xbc,0x00,
+		0xa9,0xa7,0xbe,0x00,0xa8,0xaa,0xbe,0x00,0xa8,0xae,0xc0,0x00,0xa7,0xb1,0xc0,0x00,0xbf,0xc9,0xd2,0x00,0xe8,0xed,0xef,0x00,
+		0xff,0xff,0xff,0x00,0xfe,0xef,0xff,0x00,0xfd,0xc1,0xff,0x00,0xfb,0x9e,0xff,0x00,0xfa,0x98,0xff,0x00,0xf8,0x9b,0xff,0x00,
+		0xf7,0x9b,0xfe,0x00,0xf5,0x94,0xfe,0x00,0xf5,0x9d,0xfd,0x00,0xff,0xf0,0xff,0x00,0xca,0xff,0xf2,0x00,0x5f,0xf4,0xd9,0x00,
+		0x63,0xf4,0xd9,0x00,0x62,0xf4,0xd8,0x00,0x5b,0xf3,0xd6,0x00,0x5d,0xf3,0xd6,0x00,0x93,0xf7,0xe2,0x00,0xe0,0xfd,0xf7,0x00,
+		0xff,0xff,0xff,0x00,0xe2,0xed,0xea,0x00,0xac,0xcb,0xc2,0x00,0x91,0xb8,0xac,0x00,0x91,0xb6,0xab,0x00,0x90,0xb4,0xa9,0x00,
+		0x8e,0xb0,0xa6,0x00,0x8d,0xad,0xa3,0x00,0x8b,0xa8,0x9f,0x00,0x88,0xa4,0x9b,0x00,0x83,0x9d,0x95,0x00,0x7f,0x97,0x8f,0x00,
+		0x78,0x8f,0x87,0x00,0x73,0x87,0x80,0x00,0x6b,0x7d,0x77,0x00,0x64,0x75,0x6f,0x00,0x5b,0x6a,0x65,0x00,0x52,0x60,0x5b,0x00,
+		0x4a,0x55,0x51,0x00,0x40,0x4b,0x47,0x00,0x38,0x41,0x3e,0x00,0x31,0x39,0x36,0x00,0x2b,0x32,0x2f,0x00,0x2c,0x32,0x30,0x00,
+		0x34,0x38,0x37,0x00,0x38,0x3b,0x3a,0x00,0x36,0x39,0x38,0x00,0x34,0x36,0x35,0x00,0x33,0x34,0x34,0x00,0x33,0x34,0x34,0x00,
+		0xe4,0xe4,0xe4,0x00,0xbb,0xbc,0xbc,0x00,0x34,0x35,0x35,0x00,0x36,0x37,0x37,0x00,0x36,0x37,0x36,0x00,0x37,0x37,0x38,0x00,
+		0x6d,0x6d,0x6d,0x00,0xff,0xff,0xff,0x00,0x7a,0x7b,0x7b,0x00,0x38,0x39,0x39,0x00,0x52,0x52,0x53,0x00,0xca,0xca,0xca,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xd7,0xd7,0xd7,0x00,0x5f,0x60,0x60,0x00,0x37,0x37,0x38,0x00,0x36,0x37,0x37,0x00,
+		0xff,0xff,0xff,0x00,0xc9,0xc9,0xc9,0x00,0xe5,0xe5,0xe5,0x00,0xff,0xff,0xff,0x00,0xf1,0xf1,0xf1,0x00,0x87,0x87,0x88,0x00,
+		0x37,0x37,0x38,0x00,0x37,0x37,0x38,0x00,0xff,0xff,0xff,0x00,0xc9,0xca,0xca,0x00,0xe5,0xe5,0xe5,0x00,0xff,0xff,0xff,0x00,
+		0xf1,0xf1,0xf1,0x00,0x85,0x85,0x86,0x00,0x34,0x34,0x34,0x00,0x33,0x34,0x34,0x00,0x5a,0x5a,0x5b,0x00,0xd5,0xd5,0xd6,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xc7,0xc7,0xc7,0x00,0x3a,0x3a,0x3a,0x00,0x2d,0x2d,0x2d,0x00,0x2d,0x2d,0x2d,0x00,
+		0x49,0x49,0x4a,0x00,0xd5,0xd5,0xd5,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xba,0xba,0xba,0x00,0x32,0x32,0x32,0x00,
+		0xad,0xad,0xad,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x35,0x35,0x34,0x00,0xff,0xff,0xff,0x00,
+		0x94,0x93,0x93,0x00,0x35,0x35,0x34,0x00,0xff,0xff,0xff,0x00,0xc9,0xc9,0xc9,0x00,0xe4,0xe4,0xe4,0x00,0xff,0xff,0xff,0x00,
+		0xf1,0xf1,0xf1,0x00,0x85,0x85,0x82,0x00,0x2b,0x29,0x25,0x00,0x1f,0x1c,0x17,0x00,0x36,0x35,0x2f,0x00,0xd0,0xd0,0xce,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xc2,0xc1,0xbe,0x00,0xff,0xff,0xff,0x00,0x59,0x56,0x4f,0x00,0x1e,0x1a,0x0f,0x00,
+		0x1f,0x1b,0x10,0x00,0x1f,0x1c,0x10,0x00,0x20,0x1c,0x10,0x00,0x21,0x1c,0x10,0x00,0x21,0x1c,0x10,0x00,0x22,0x1d,0x10,0x00,
+		0x22,0x1d,0x10,0x00,0x22,0x1d,0x10,0x00,0x21,0x1c,0x0f,0x00,0x21,0x1c,0x0f,0x00,0x21,0x1c,0x0f,0x00,0x21,0x1c,0x0f,0x00,
+		0x20,0x1b,0x0e,0x00,0x21,0x1c,0x0e,0x00,0x21,0x1c,0x0e,0x00,0x21,0x1c,0x0e,0x00,0x21,0x1c,0x0e,0x00,0x22,0x1c,0x0e,0x00,
+		0x22,0x1d,0x0e,0x00,0x22,0x1c,0x0e,0x00,0x23,0x1d,0x0e,0x00,0x24,0x1e,0x0f,0x00,0x25,0x1f,0x0f,0x00,0x25,0x1f,0x0f,0x00,
+		0x25,0x1f,0x0f,0x00,0x26,0x20,0x0f,0x00,0x26,0x20,0x0f,0x00,0x26,0x20,0x0e,0x00,0x26,0x20,0x0e,0x00,0x26,0x20,0x0e,0x00,
+		0x26,0x20,0x0e,0x00,0x27,0x21,0x0e,0x00,0x27,0x21,0x0e,0x00,0x27,0x21,0x0e,0x00,0x26,0x20,0x0e,0x00,0x26,0x1f,0x0e,0x00,
+		0x24,0x1e,0x0d,0x00,0x25,0x1f,0x0d,0x00,0x23,0x1d,0x0c,0x00,0x21,0x1c,0x0b,0x00,0x20,0x1a,0x09,0x00,0x1f,0x1a,0x09,0x00,
+		0x1e,0x18,0x07,0x00,0x1b,0x16,0x05,0x00,0x1b,0x15,0x05,0x00,0x19,0x13,0x03,0x00,0x18,0x12,0x02,0x00,0x17,0x11,0x01,0x00,
+		0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x16,0x11,0x00,0x00,0x16,0x11,0x00,0x00,
+		0x16,0x10,0x00,0x00,0x17,0x11,0x00,0x00,0x17,0x11,0x00,0x00,0x17,0x11,0x00,0x00,0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,
+		0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,
+		0x18,0x12,0x00,0x00,0x18,0x12,0x00,0x00,0x17,0x11,0x00,0x00,0x16,0x11,0x00,0x00,0x16,0x10,0x00,0x00,0x15,0x10,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x14,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x11,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x0f,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x23,0x00,0x22,0x21,0x22,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x24,0x24,0x25,0x00,
+		0x26,0x25,0x26,0x00,0x27,0x25,0x28,0x00,0x27,0x25,0x28,0x00,0x2a,0x27,0x2a,0x00,0x2b,0x28,0x2b,0x00,0x2c,0x29,0x2e,0x00,
+		0x2e,0x2a,0x2f,0x00,0x30,0x2b,0x30,0x00,0x32,0x2d,0x33,0x00,0x31,0x2a,0x32,0x00,0x30,0x29,0x31,0x00,0x2c,0x24,0x2d,0x00,
+		0x26,0x1e,0x28,0x00,0x23,0x18,0x25,0x00,0x22,0x17,0x25,0x00,0x25,0x18,0x28,0x00,0x27,0x19,0x2a,0x00,0x2b,0x1b,0x2d,0x00,
+		0x2d,0x1c,0x30,0x00,0x30,0x1f,0x33,0x00,0x34,0x21,0x37,0x00,0x35,0x22,0x39,0x00,0x39,0x24,0x3d,0x00,0x3d,0x27,0x41,0x00,
+		0x3f,0x28,0x44,0x00,0x44,0x2d,0x49,0x00,0x48,0x2f,0x4c,0x00,0x4d,0x33,0x52,0x00,0x51,0x37,0x56,0x00,0x57,0x3b,0x5b,0x00,
+		0x5b,0x41,0x61,0x00,0x61,0x45,0x68,0x00,0x68,0x4d,0x6f,0x00,0x6e,0x53,0x75,0x00,0x75,0x5a,0x7d,0x00,0x7b,0x60,0x83,0x00,
+		0x81,0x68,0x8a,0x00,0x87,0x6e,0x91,0x00,0x8d,0x76,0x97,0x00,0x93,0x7e,0x9e,0x00,0x96,0x83,0xa2,0x00,0x9a,0x89,0xa7,0x00,
+		0x9f,0x90,0xad,0x00,0xa1,0x95,0xb1,0x00,0xa3,0x9b,0xb5,0x00,0xa5,0x9f,0xb7,0x00,0xa7,0xa5,0xbb,0x00,0xa5,0xa7,0xbb,0x00,
+		0xa6,0xac,0xbd,0x00,0xa6,0xaf,0xbe,0x00,0xa4,0xb2,0xbf,0x00,0xa6,0xb6,0xc1,0x00,0xc7,0xd4,0xd9,0x00,0xf1,0xf4,0xf5,0x00,
+		0xff,0xff,0xff,0x00,0xfe,0xe4,0xff,0x00,0xfd,0xb5,0xff,0x00,0xfa,0x9b,0xff,0x00,0xf9,0x9a,0xff,0x00,0xf7,0x98,0xfe,0x00,
+		0xf7,0xa0,0xfe,0x00,0xff,0xf0,0xff,0x00,0xca,0xff,0xf2,0x00,0x60,0xf4,0xda,0x00,0x5e,0xf4,0xd9,0x00,0x5b,0xf4,0xd8,0x00,
+		0x82,0xf6,0xe0,0x00,0xce,0xfb,0xf3,0x00,0xff,0xff,0xff,0x00,0xee,0xf4,0xf3,0x00,0xbc,0xd5,0xce,0x00,0x95,0xbb,0xb0,0x00,
+		0x92,0xb7,0xac,0x00,0x91,0xb5,0xaa,0x00,0x8f,0xb2,0xa8,0x00,0x8d,0xae,0xa4,0x00,0x8b,0xaa,0xa0,0x00,0x89,0xa6,0x9c,0x00,
+		0x85,0xa0,0x98,0x00,0x80,0x9a,0x91,0x00,0x7a,0x92,0x8a,0x00,0x75,0x8b,0x84,0x00,0x6d,0x81,0x7b,0x00,0x66,0x78,0x72,0x00,
+		0x5e,0x6f,0x69,0x00,0x55,0x64,0x5f,0x00,0x4c,0x5a,0x55,0x00,0x44,0x50,0x4b,0x00,0x3b,0x46,0x42,0x00,0x33,0x3d,0x39,0x00,
+		0x2c,0x35,0x32,0x00,0x2a,0x32,0x2f,0x00,0x2d,0x33,0x31,0x00,0x36,0x3a,0x38,0x00,0x36,0x3a,0x39,0x00,0x34,0x37,0x35,0x00,
+		0x32,0x34,0x34,0x00,0x2f,0x31,0x31,0x00,0x2f,0x30,0x2f,0x00,0x59,0x5a,0x5a,0x00,0xff,0xff,0xff,0x00,0x74,0x75,0x75,0x00,
+		0x2f,0x30,0x30,0x00,0x30,0x31,0x31,0x00,0x30,0x30,0x30,0x00,0x31,0x31,0x31,0x00,0x31,0x31,0x31,0x00,0x32,0x32,0x33,0x00,
+		0x32,0x32,0x33,0x00,0x32,0x33,0x33,0x00,0xd6,0xd6,0xd6,0x00,0xe4,0xe4,0xe4,0x00,0x4d,0x4d,0x4d,0x00,0x3f,0x3f,0x3f,0x00,
+		0xd6,0xd6,0xd6,0x00,0xf1,0xf1,0xf1,0x00,0x4c,0x4c,0x4d,0x00,0x31,0x31,0x32,0x00,0xff,0xff,0xff,0x00,0xf1,0xf1,0xf1,0x00,
+		0x68,0x68,0x68,0x00,0x31,0x31,0x32,0x00,0xc8,0xc8,0xc9,0x00,0xff,0xff,0xff,0x00,0x3f,0x3f,0x40,0x00,0x31,0x31,0x32,0x00,
+		0xff,0xff,0xff,0x00,0xf1,0xf1,0xf1,0x00,0x68,0x68,0x68,0x00,0x31,0x31,0x31,0x00,0xc8,0xc8,0xc8,0x00,0xff,0xff,0xff,0x00,
+		0x3d,0x3d,0x3e,0x00,0x3d,0x3d,0x3d,0x00,0xe3,0xe3,0xe3,0x00,0xc7,0xc7,0xc7,0x00,0x2d,0x2d,0x2d,0x00,0x47,0x47,0x47,0x00,
+		0xd4,0xd4,0xd4,0x00,0xc6,0xc6,0xc7,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,0xd4,0xd4,0xd4,0x00,0xe3,0xe3,0xe3,0x00,
+		0x3a,0x3a,0x3a,0x00,0x73,0x73,0x73,0x00,0xff,0xff,0xff,0x00,0x90,0x90,0x90,0x00,0x2f,0x2f,0x2e,0x00,0xc7,0xc7,0xc7,0x00,
+		0xc8,0xc8,0xc8,0x00,0x2f,0x2f,0x2f,0x00,0x2f,0x2f,0x2e,0x00,0xff,0xff,0xff,0x00,0x90,0x90,0x90,0x00,0x2f,0x2f,0x2e,0x00,
+		0xff,0xff,0xff,0x00,0xf1,0xf1,0xf1,0x00,0x67,0x66,0x64,0x00,0x2f,0x2f,0x2c,0x00,0xc7,0xc7,0xc6,0x00,0xff,0xff,0xff,0x00,
+		0x24,0x23,0x1f,0x00,0x0f,0x0d,0x08,0x00,0xcf,0xce,0xcd,0x00,0xcf,0xce,0xcd,0x00,0x20,0x1e,0x18,0x00,0x41,0x3e,0x39,0x00,
+		0xdf,0xdf,0xde,0x00,0xff,0xff,0xff,0x00,0x53,0x50,0x4b,0x00,0x15,0x12,0x09,0x00,0x17,0x13,0x09,0x00,0x17,0x14,0x09,0x00,
+		0x17,0x14,0x09,0x00,0x18,0x14,0x09,0x00,0x18,0x14,0x09,0x00,0x18,0x15,0x09,0x00,0x18,0x15,0x09,0x00,0x19,0x15,0x09,0x00,
+		0x18,0x14,0x08,0x00,0x18,0x14,0x08,0x00,0x17,0x13,0x07,0x00,0x17,0x13,0x07,0x00,0x17,0x13,0x07,0x00,0x17,0x13,0x07,0x00,
+		0x17,0x13,0x07,0x00,0x17,0x14,0x07,0x00,0x18,0x14,0x07,0x00,0x18,0x14,0x07,0x00,0x18,0x14,0x07,0x00,0x19,0x14,0x07,0x00,
+		0x19,0x15,0x07,0x00,0x19,0x15,0x07,0x00,0x1a,0x15,0x07,0x00,0x1a,0x16,0x07,0x00,0x1b,0x16,0x07,0x00,0x1b,0x16,0x07,0x00,
+		0x1c,0x17,0x07,0x00,0x1c,0x17,0x07,0x00,0x1c,0x17,0x07,0x00,0x1c,0x17,0x07,0x00,0x1d,0x17,0x07,0x00,0x1d,0x18,0x07,0x00,
+		0x1d,0x18,0x07,0x00,0x1d,0x18,0x07,0x00,0x1d,0x18,0x07,0x00,0x1d,0x17,0x07,0x00,0x1c,0x17,0x07,0x00,0x1c,0x17,0x07,0x00,
+		0x1b,0x16,0x06,0x00,0x1b,0x16,0x06,0x00,0x1b,0x15,0x06,0x00,0x19,0x13,0x05,0x00,0x18,0x12,0x04,0x00,0x17,0x12,0x03,0x00,
+		0x16,0x10,0x02,0x00,0x15,0x0f,0x01,0x00,0x14,0x0f,0x01,0x00,0x14,0x0f,0x01,0x00,0x13,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,
+		0x14,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,0x13,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,
+		0x14,0x10,0x00,0x00,0x14,0x0f,0x00,0x00,0x15,0x0f,0x00,0x00,0x15,0x0f,0x00,0x00,0x15,0x0f,0x00,0x00,0x15,0x10,0x00,0x00,
+		0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x15,0x10,0x00,0x00,0x15,0x0f,0x00,0x00,0x15,0x0f,0x00,0x00,
+		0x15,0x0f,0x00,0x00,0x14,0x0f,0x00,0x00,0x14,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,
+		0x11,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x09,0x00,0x00,0x0c,0x08,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x22,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x24,0x24,0x25,0x00,0x25,0x24,0x26,0x00,
+		0x27,0x25,0x27,0x00,0x29,0x27,0x29,0x00,0x29,0x28,0x2a,0x00,0x2b,0x28,0x2c,0x00,0x2d,0x2a,0x2e,0x00,0x2f,0x2b,0x30,0x00,
+		0x30,0x2b,0x31,0x00,0x32,0x2d,0x33,0x00,0x35,0x2e,0x35,0x00,0x36,0x2f,0x36,0x00,0x35,0x2e,0x37,0x00,0x35,0x2c,0x36,0x00,
+		0x30,0x25,0x32,0x00,0x2a,0x20,0x2d,0x00,0x28,0x1c,0x2b,0x00,0x2a,0x1d,0x2c,0x00,0x2c,0x1c,0x2e,0x00,0x2d,0x1e,0x31,0x00,
+		0x30,0x20,0x33,0x00,0x33,0x21,0x37,0x00,0x37,0x23,0x3a,0x00,0x3a,0x25,0x3d,0x00,0x3c,0x27,0x40,0x00,0x40,0x2a,0x44,0x00,
+		0x44,0x2d,0x49,0x00,0x47,0x30,0x4b,0x00,0x4b,0x33,0x50,0x00,0x50,0x37,0x55,0x00,0x54,0x3a,0x59,0x00,0x5a,0x3f,0x5f,0x00,
+		0x5f,0x44,0x65,0x00,0x65,0x4b,0x6b,0x00,0x6c,0x51,0x73,0x00,0x70,0x58,0x78,0x00,0x76,0x5e,0x7e,0x00,0x7c,0x65,0x85,0x00,
+		0x82,0x6c,0x8c,0x00,0x89,0x74,0x93,0x00,0x8d,0x7b,0x99,0x00,0x92,0x81,0x9f,0x00,0x96,0x88,0xa4,0x00,0x9a,0x8e,0xa9,0x00,
+		0x9c,0x94,0xad,0x00,0x9e,0x99,0xb0,0x00,0xa0,0x9f,0xb3,0x00,0xa2,0xa4,0xb7,0x00,0xa2,0xa7,0xb8,0x00,0xa3,0xad,0xbb,0x00,
+		0xa3,0xb0,0xbc,0x00,0xa2,0xb2,0xbc,0x00,0xa1,0xb4,0xbd,0x00,0xaa,0xbf,0xc4,0x00,0xd2,0xde,0xe0,0x00,0xfa,0xfb,0xfb,0x00,
+		0xff,0xfd,0xff,0x00,0xfe,0xd8,0xff,0x00,0xfb,0xa9,0xff,0x00,0xf9,0x95,0xff,0x00,0xf9,0xa0,0xff,0x00,0xff,0xf0,0xff,0x00,
+		0xc8,0xff,0xf3,0x00,0x55,0xf4,0xd9,0x00,0x72,0xf6,0xdf,0x00,0xbc,0xfa,0xf0,0x00,0xf8,0xfe,0xfd,0x00,0xf7,0xfa,0xfa,0x00,
+		0xca,0xde,0xd9,0x00,0x9d,0xc0,0xb6,0x00,0x92,0xb8,0xae,0x00,0x91,0xb5,0xab,0x00,0x8f,0xb3,0xa9,0x00,0x8f,0xb0,0xa7,0x00,
+		0x8c,0xac,0xa3,0x00,0x89,0xa7,0x9e,0x00,0x86,0xa2,0x9a,0x00,0x81,0x9b,0x94,0x00,0x7c,0x96,0x8d,0x00,0x76,0x8e,0x86,0x00,
+		0x70,0x86,0x7f,0x00,0x68,0x7c,0x76,0x00,0x60,0x73,0x6c,0x00,0x58,0x69,0x63,0x00,0x4f,0x5e,0x5a,0x00,0x47,0x55,0x50,0x00,
+		0x3f,0x4b,0x47,0x00,0x37,0x42,0x3e,0x00,0x2f,0x38,0x35,0x00,0x29,0x32,0x2f,0x00,0x2a,0x31,0x2f,0x00,0x30,0x37,0x34,0x00,
+		0x35,0x39,0x38,0x00,0x34,0x39,0x38,0x00,0x32,0x35,0x34,0x00,0x30,0x33,0x32,0x00,0x2e,0x30,0x2f,0x00,0x2d,0x2f,0x2e,0x00,
+		0x2c,0x2e,0x2e,0x00,0x80,0x81,0x81,0x00,0xff,0xff,0xff,0x00,0x48,0x49,0x49,0x00,0x2c,0x2d,0x2c,0x00,0x2d,0x2d,0x2d,0x00,
+		0x2d,0x2d,0x2d,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x57,0x57,0x58,0x00,
+		0xff,0xff,0xff,0x00,0x73,0x74,0x74,0x00,0x2f,0x2f,0x2f,0x00,0x2f,0x2f,0x2f,0x00,0x4a,0x4a,0x4a,0x00,0xff,0xff,0xff,0x00,
+		0x90,0x90,0x90,0x00,0x2e,0x2e,0x2e,0x00,0xff,0xff,0xff,0x00,0xb9,0xb9,0xb9,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2e,0x00,
+		0x81,0x81,0x81,0x00,0xff,0xff,0xff,0x00,0x57,0x57,0x57,0x00,0x2e,0x2e,0x2e,0x00,0xff,0xff,0xff,0x00,0xb9,0xb9,0xb9,0x00,
+		0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x81,0x81,0x81,0x00,0xff,0xff,0xff,0x00,0x57,0x57,0x57,0x00,0x8f,0x8f,0x8f,0x00,
+		0xff,0xff,0xff,0x00,0x3a,0x3a,0x3a,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,0x71,0x71,0x71,0x00,0xff,0xff,0xff,0x00,
+		0x54,0x54,0x54,0x00,0x54,0x54,0x54,0x00,0xff,0xff,0xff,0x00,0x8d,0x8d,0x8d,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,
+		0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,0xc6,0xc6,0xc6,0x00,0xc7,0xc7,0xc7,0x00,0x2b,0x2b,0x2a,0x00,
+		0x2b,0x2b,0x2a,0x00,0xff,0xff,0xff,0x00,0x8e,0x8e,0x8e,0x00,0x2b,0x2b,0x2a,0x00,0xff,0xff,0xff,0x00,0xb8,0xb8,0xb8,0x00,
+		0x2a,0x2a,0x28,0x00,0x24,0x23,0x21,0x00,0x73,0x73,0x71,0x00,0xff,0xff,0xff,0x00,0x3a,0x3a,0x36,0x00,0x3a,0x39,0x35,0x00,
+		0xff,0xff,0xff,0x00,0x5c,0x5a,0x57,0x00,0x0b,0x09,0x03,0x00,0x0c,0x09,0x03,0x00,0x7e,0x7d,0x79,0x00,0xff,0xff,0xff,0x00,
+		0x4f,0x4e,0x48,0x00,0x10,0x0d,0x05,0x00,0x11,0x0d,0x05,0x00,0x10,0x0d,0x05,0x00,0x11,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,
+		0x12,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,0x12,0x0e,0x05,0x00,
+		0x12,0x0e,0x05,0x00,0x12,0x0e,0x04,0x00,0x12,0x0e,0x04,0x00,0x12,0x0e,0x04,0x00,0x12,0x0e,0x04,0x00,0x12,0x0e,0x04,0x00,
+		0x12,0x0e,0x04,0x00,0x13,0x0f,0x04,0x00,0x13,0x0f,0x04,0x00,0x13,0x0f,0x04,0x00,0x14,0x0f,0x04,0x00,0x14,0x10,0x04,0x00,
+		0x15,0x11,0x05,0x00,0x16,0x11,0x05,0x00,0x16,0x11,0x05,0x00,0x17,0x12,0x05,0x00,0x17,0x12,0x05,0x00,0x17,0x12,0x05,0x00,
+		0x18,0x13,0x05,0x00,0x18,0x13,0x05,0x00,0x18,0x13,0x05,0x00,0x18,0x13,0x05,0x00,0x18,0x13,0x05,0x00,0x17,0x12,0x04,0x00,
+		0x17,0x12,0x04,0x00,0x17,0x12,0x04,0x00,0x17,0x12,0x04,0x00,0x17,0x12,0x04,0x00,0x16,0x11,0x03,0x00,0x15,0x10,0x03,0x00,
+		0x15,0x10,0x03,0x00,0x15,0x10,0x03,0x00,0x14,0x0f,0x02,0x00,0x12,0x0e,0x01,0x00,0x12,0x0e,0x01,0x00,0x12,0x0e,0x01,0x00,
+		0x11,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,0x10,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,
+		0x11,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,0x11,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,0x11,0x0e,0x00,0x00,0x12,0x0e,0x00,0x00,
+		0x12,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,0x13,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,
+		0x13,0x0e,0x00,0x00,0x13,0x0e,0x00,0x00,0x12,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,0x12,0x0d,0x00,0x00,
+		0x11,0x0c,0x00,0x00,0x11,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0d,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x23,0x00,0x23,0x22,0x23,0x00,
+		0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x26,0x28,0x00,0x27,0x26,0x28,0x00,
+		0x2a,0x28,0x2a,0x00,0x2b,0x28,0x2b,0x00,0x2c,0x29,0x2d,0x00,0x2d,0x2a,0x2f,0x00,0x2e,0x2b,0x2f,0x00,0x31,0x2c,0x31,0x00,
+		0x33,0x2d,0x34,0x00,0x36,0x30,0x36,0x00,0x37,0x30,0x38,0x00,0x39,0x31,0x3b,0x00,0x3b,0x33,0x3c,0x00,0x3b,0x32,0x3c,0x00,
+		0x37,0x2e,0x3a,0x00,0x32,0x27,0x35,0x00,0x30,0x23,0x33,0x00,0x2e,0x20,0x31,0x00,0x2f,0x20,0x32,0x00,0x30,0x20,0x33,0x00,
+		0x33,0x21,0x37,0x00,0x36,0x24,0x3a,0x00,0x38,0x25,0x3b,0x00,0x3d,0x27,0x3f,0x00,0x3f,0x2a,0x43,0x00,0x43,0x2d,0x46,0x00,
+		0x47,0x30,0x4b,0x00,0x4a,0x33,0x4e,0x00,0x4d,0x35,0x52,0x00,0x52,0x3a,0x57,0x00,0x56,0x3e,0x5c,0x00,0x5b,0x43,0x61,0x00,
+		0x61,0x49,0x67,0x00,0x66,0x4f,0x6d,0x00,0x6b,0x55,0x73,0x00,0x72,0x5b,0x7a,0x00,0x78,0x62,0x80,0x00,0x7d,0x69,0x87,0x00,
+		0x82,0x70,0x8d,0x00,0x87,0x78,0x93,0x00,0x8c,0x7f,0x99,0x00,0x90,0x85,0x9e,0x00,0x93,0x8c,0xa3,0x00,0x97,0x92,0xa8,0x00,
+		0x9a,0x99,0xac,0x00,0x9d,0x9f,0xb1,0x00,0x9f,0xa4,0xb4,0x00,0x9f,0xa8,0xb6,0x00,0x9f,0xac,0xb7,0x00,0x9f,0xaf,0xb9,0x00,
+		0xa0,0xb3,0xba,0x00,0x9f,0xb5,0xba,0x00,0x9e,0xb7,0xbb,0x00,0xaf,0xc6,0xc8,0x00,0xdd,0xe7,0xe7,0x00,0xfd,0xfd,0xfd,0x00,
+		0xff,0xf6,0xff,0x00,0xfd,0xc9,0xff,0x00,0xfb,0xa9,0xff,0x00,0xff,0xef,0xff,0x00,0xce,0xff,0xf4,0x00,0xa1,0xf9,0xea,0x00,
+		0xed,0xfe,0xfb,0x00,0xfc,0xfd,0xfd,0x00,0xd9,0xe6,0xe3,0x00,0xa6,0xc5,0xbe,0x00,0x93,0xb8,0xae,0x00,0x92,0xb7,0xad,0x00,
+		0x91,0xb5,0xab,0x00,0x8f,0xb1,0xa8,0x00,0x8c,0xad,0xa4,0x00,0x89,0xa9,0xa0,0x00,0x86,0xa4,0x9c,0x00,0x82,0x9e,0x96,0x00,
+		0x7d,0x98,0x90,0x00,0x78,0x90,0x89,0x00,0x72,0x89,0x82,0x00,0x6b,0x80,0x79,0x00,0x62,0x76,0x70,0x00,0x5a,0x6d,0x67,0x00,
+		0x52,0x64,0x5e,0x00,0x49,0x59,0x54,0x00,0x41,0x4f,0x4a,0x00,0x39,0x46,0x41,0x00,0x32,0x3d,0x39,0x00,0x2b,0x34,0x31,0x00,
+		0x27,0x30,0x2d,0x00,0x29,0x31,0x2e,0x00,0x31,0x38,0x35,0x00,0x34,0x39,0x38,0x00,0x33,0x37,0x35,0x00,0x31,0x34,0x34,0x00,
+		0x2f,0x32,0x31,0x00,0x2d,0x2f,0x2f,0x00,0x2c,0x2e,0x2d,0x00,0x2a,0x2c,0x2c,0x00,0x2a,0x2c,0x2b,0x00,0x7f,0x80,0x80,0x00,
+		0xff,0xff,0xff,0x00,0x45,0x46,0x46,0x00,0x29,0x2a,0x2a,0x00,0x2a,0x2b,0x2b,0x00,0x2a,0x2b,0x2b,0x00,0x2a,0x2b,0x2b,0x00,
+		0x2a,0x2b,0x2b,0x00,0x2b,0x2c,0x2c,0x00,0x2b,0x2c,0x2c,0x00,0x80,0x80,0x80,0x00,0xff,0xff,0xff,0x00,0x48,0x48,0x48,0x00,
+		0x2b,0x2b,0x2b,0x00,0x2b,0x2b,0x2b,0x00,0x2b,0x2b,0x2b,0x00,0xe3,0xe3,0xe3,0x00,0xaa,0xaa,0xab,0x00,0x2b,0x2b,0x2c,0x00,
+		0xff,0xff,0xff,0x00,0x8e,0x8e,0x8f,0x00,0x2b,0x2b,0x2c,0x00,0x2b,0x2b,0x2c,0x00,0x80,0x80,0x80,0x00,0xff,0xff,0xff,0x00,
+		0x63,0x63,0x64,0x00,0x2b,0x2b,0x2c,0x00,0xff,0xff,0xff,0x00,0x8e,0x8e,0x8e,0x00,0x2b,0x2b,0x2b,0x00,0x2b,0x2b,0x2b,0x00,
+		0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x63,0x63,0x63,0x00,0xaa,0xaa,0xaa,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x62,0x62,0x62,0x00,0x7f,0x7f,0x7f,0x00,
+		0xff,0xff,0xff,0x00,0x70,0x71,0x71,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,
+		0x29,0x29,0x29,0x00,0xc6,0xc6,0xc6,0x00,0xc6,0xc6,0xc6,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0xff,0xff,0xff,0x00,
+		0x8d,0x8d,0x8d,0x00,0x29,0x29,0x28,0x00,0xff,0xff,0xff,0x00,0x8c,0x8c,0x8b,0x00,0x1c,0x1b,0x19,0x00,0x0d,0x0c,0x0a,0x00,
+		0x6a,0x69,0x68,0x00,0xff,0xff,0xff,0x00,0x48,0x47,0x45,0x00,0x6a,0x69,0x67,0x00,0xff,0xff,0xff,0x00,0x28,0x27,0x23,0x00,
+		0x08,0x06,0x01,0x00,0x08,0x06,0x01,0x00,0x4b,0x4a,0x45,0x00,0xff,0xff,0xff,0x00,0x4b,0x4b,0x45,0x00,0x0b,0x09,0x02,0x00,
+		0x0d,0x0a,0x03,0x00,0x0d,0x0a,0x03,0x00,0x0e,0x0b,0x03,0x00,0x0e,0x0b,0x03,0x00,0x0d,0x0b,0x03,0x00,0x0e,0x0b,0x03,0x00,
+		0x0e,0x0b,0x03,0x00,0x0e,0x0b,0x03,0x00,0x0e,0x0b,0x03,0x00,0x0d,0x0a,0x02,0x00,0x0d,0x0a,0x02,0x00,0x0d,0x0a,0x02,0x00,
+		0x0e,0x0a,0x02,0x00,0x0e,0x0b,0x02,0x00,0x0e,0x0b,0x02,0x00,0x0e,0x0b,0x02,0x00,0x0e,0x0b,0x02,0x00,0x0e,0x0b,0x02,0x00,
+		0x0f,0x0b,0x02,0x00,0x0f,0x0c,0x02,0x00,0x0f,0x0c,0x02,0x00,0x10,0x0c,0x02,0x00,0x10,0x0c,0x02,0x00,0x10,0x0c,0x02,0x00,
+		0x11,0x0d,0x02,0x00,0x11,0x0d,0x02,0x00,0x11,0x0d,0x02,0x00,0x12,0x0e,0x02,0x00,0x12,0x0d,0x02,0x00,0x12,0x0d,0x02,0x00,
+		0x12,0x0e,0x02,0x00,0x13,0x0e,0x02,0x00,0x13,0x0e,0x02,0x00,0x13,0x0e,0x02,0x00,0x13,0x0e,0x02,0x00,0x13,0x0e,0x02,0x00,
+		0x12,0x0e,0x02,0x00,0x11,0x0d,0x01,0x00,0x11,0x0d,0x01,0x00,0x11,0x0d,0x01,0x00,0x11,0x0d,0x01,0x00,0x11,0x0c,0x01,0x00,
+		0x10,0x0c,0x01,0x00,0x10,0x0c,0x01,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,
+		0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0f,0x0c,0x00,0x00,0x0f,0x0c,0x00,0x00,0x11,0x0d,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x10,0x0d,0x00,0x00,0x10,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,
+		0x10,0x0c,0x00,0x00,0x10,0x0c,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0f,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0e,0x0a,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0c,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x03,0x03,0x00,0x00,0x04,0x02,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,
+		0x25,0x24,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x25,0x28,0x00,0x29,0x27,0x2a,0x00,0x2a,0x28,0x2b,0x00,
+		0x2b,0x28,0x2b,0x00,0x2d,0x2a,0x2e,0x00,0x2e,0x2b,0x2f,0x00,0x30,0x2b,0x31,0x00,0x32,0x2d,0x33,0x00,0x33,0x2e,0x34,0x00,
+		0x37,0x30,0x38,0x00,0x37,0x31,0x38,0x00,0x3a,0x33,0x3c,0x00,0x3c,0x34,0x3d,0x00,0x3e,0x35,0x40,0x00,0x40,0x37,0x41,0x00,
+		0x40,0x36,0x42,0x00,0x3c,0x30,0x3e,0x00,0x38,0x2b,0x3a,0x00,0x33,0x25,0x35,0x00,0x32,0x22,0x35,0x00,0x34,0x23,0x36,0x00,
+		0x36,0x24,0x39,0x00,0x38,0x26,0x3c,0x00,0x3b,0x28,0x3f,0x00,0x3e,0x2a,0x41,0x00,0x41,0x2c,0x45,0x00,0x45,0x30,0x49,0x00,
+		0x48,0x32,0x4b,0x00,0x4b,0x35,0x50,0x00,0x4f,0x39,0x54,0x00,0x54,0x3d,0x59,0x00,0x58,0x42,0x5e,0x00,0x5d,0x47,0x64,0x00,
+		0x61,0x4b,0x68,0x00,0x67,0x52,0x6f,0x00,0x6d,0x59,0x75,0x00,0x70,0x5e,0x7a,0x00,0x78,0x67,0x81,0x00,0x7c,0x6d,0x87,0x00,
+		0x81,0x75,0x8e,0x00,0x86,0x7c,0x94,0x00,0x8a,0x83,0x99,0x00,0x8e,0x8a,0x9e,0x00,0x92,0x91,0xa4,0x00,0x96,0x98,0xa9,0x00,
+		0x98,0x9e,0xad,0x00,0x9a,0xa2,0xaf,0x00,0x9b,0xa7,0xb3,0x00,0x9c,0xab,0xb4,0x00,0x9d,0xaf,0xb6,0x00,0x9d,0xb2,0xb8,0x00,
+		0x9d,0xb5,0xb8,0x00,0x9c,0xb7,0xb8,0x00,0x9c,0xb9,0xb9,0x00,0xb9,0xcf,0xcd,0x00,0xe9,0xf0,0xef,0x00,0xff,0xff,0xff,0x00,
+		0xfe,0xef,0xff,0x00,0xff,0xf9,0xff,0x00,0xfc,0xff,0xfe,0x00,0xff,0xff,0xff,0x00,0xe5,0xee,0xec,0x00,0xb4,0xcd,0xc8,0x00,
+		0x94,0xb8,0xb0,0x00,0x94,0xb7,0xae,0x00,0x92,0xb5,0xac,0x00,0x91,0xb3,0xaa,0x00,0x8e,0xaf,0xa6,0x00,0x8c,0xab,0xa3,0x00,
+		0x88,0xa6,0x9e,0x00,0x84,0xa0,0x99,0x00,0x7f,0x9a,0x92,0x00,0x7a,0x93,0x8c,0x00,0x73,0x8c,0x84,0x00,0x6d,0x84,0x7d,0x00,
+		0x64,0x7a,0x73,0x00,0x5d,0x71,0x6b,0x00,0x55,0x67,0x62,0x00,0x4c,0x5d,0x57,0x00,0x43,0x53,0x4e,0x00,0x3c,0x4a,0x45,0x00,
+		0x34,0x40,0x3c,0x00,0x2d,0x38,0x34,0x00,0x27,0x31,0x2e,0x00,0x25,0x2e,0x2b,0x00,0x2b,0x33,0x30,0x00,0x33,0x39,0x37,0x00,
+		0x34,0x39,0x37,0x00,0x32,0x36,0x34,0x00,0x2f,0x33,0x32,0x00,0x2e,0x31,0x2f,0x00,0x2d,0x2f,0x2f,0x00,0x2b,0x2d,0x2c,0x00,
+		0x2a,0x2c,0x2c,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x53,0x55,0x54,0x00,0xff,0xff,0xff,0x00,0x70,0x71,0x70,0x00,
+		0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x8d,0x8d,0x8d,0x00,
+		0x62,0x62,0x62,0x00,0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x45,0x45,0x45,0x00,0x29,0x29,0x2a,0x00,0x29,0x29,0x2a,0x00,
+		0x29,0x2a,0x2a,0x00,0xe3,0xe3,0xe3,0x00,0xaa,0xaa,0xaa,0x00,0x29,0x2a,0x2a,0x00,0xff,0xff,0xff,0x00,0x8e,0x8e,0x8e,0x00,
+		0x2a,0x2a,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x62,0x63,0x63,0x00,0x29,0x2a,0x2a,0x00,
+		0xff,0xff,0xff,0x00,0x8d,0x8d,0x8e,0x00,0x29,0x29,0x2a,0x00,0x29,0x29,0x29,0x00,0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,
+		0x62,0x62,0x62,0x00,0xa9,0xa9,0xa9,0x00,0xf1,0xf1,0xf1,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,
+		0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x7e,0x7e,0x7f,0x00,0xff,0xff,0xff,0x00,0x6f,0x6f,0x6f,0x00,
+		0x28,0x28,0x29,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0xc6,0xc6,0xc6,0x00,
+		0xc6,0xc6,0xc5,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0xff,0xff,0xff,0x00,0x8c,0x8c,0x8c,0x00,0x28,0x27,0x26,0x00,
+		0xff,0xff,0xff,0x00,0x80,0x80,0x80,0x00,0x07,0x07,0x05,0x00,0x04,0x03,0x01,0x00,0x68,0x67,0x66,0x00,0xff,0xff,0xff,0x00,
+		0x47,0x46,0x44,0x00,0x69,0x68,0x66,0x00,0xff,0xff,0xff,0x00,0x27,0x25,0x22,0x00,0x06,0x04,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x4a,0x48,0x45,0x00,0xff,0xff,0xff,0x00,0x4b,0x49,0x45,0x00,0x08,0x07,0x01,0x00,0x09,0x07,0x01,0x00,0x0a,0x07,0x01,0x00,
+		0x0a,0x07,0x01,0x00,0x0a,0x08,0x01,0x00,0x0a,0x08,0x01,0x00,0x0a,0x08,0x01,0x00,0x0a,0x08,0x01,0x00,0x0a,0x08,0x01,0x00,
+		0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,
+		0x0b,0x08,0x01,0x00,0x0b,0x08,0x01,0x00,0x0b,0x09,0x01,0x00,0x0b,0x09,0x01,0x00,0x0c,0x09,0x01,0x00,0x0c,0x09,0x01,0x00,
+		0x0c,0x09,0x01,0x00,0x0d,0x09,0x01,0x00,0x0d,0x0a,0x01,0x00,0x0d,0x0a,0x01,0x00,0x0e,0x0a,0x01,0x00,0x0e,0x0a,0x01,0x00,
+		0x0e,0x0b,0x01,0x00,0x0e,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,
+		0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0f,0x0b,0x01,0x00,0x0e,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,
+		0x0e,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,
+		0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0e,0x0a,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0b,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0e,0x0b,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0e,0x0b,0x00,0x00,0x0e,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,0x0d,0x0a,0x00,0x00,
+		0x0d,0x09,0x00,0x00,0x0d,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x04,0x00,0x00,0x04,0x04,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,
+		0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x28,0x26,0x28,0x00,0x2a,0x27,0x2a,0x00,0x2a,0x28,0x2b,0x00,0x2a,0x29,0x2b,0x00,
+		0x2d,0x2a,0x2e,0x00,0x2e,0x2b,0x2f,0x00,0x30,0x2c,0x31,0x00,0x32,0x2e,0x34,0x00,0x34,0x30,0x35,0x00,0x36,0x31,0x36,0x00,
+		0x37,0x31,0x38,0x00,0x3b,0x33,0x3c,0x00,0x3c,0x35,0x3d,0x00,0x3f,0x37,0x40,0x00,0x41,0x37,0x42,0x00,0x43,0x39,0x45,0x00,
+		0x43,0x39,0x45,0x00,0x41,0x36,0x43,0x00,0x3d,0x30,0x40,0x00,0x39,0x29,0x3b,0x00,0x35,0x25,0x37,0x00,0x36,0x25,0x39,0x00,
+		0x37,0x25,0x3a,0x00,0x3a,0x28,0x3e,0x00,0x3d,0x2a,0x40,0x00,0x40,0x2c,0x43,0x00,0x43,0x2e,0x47,0x00,0x47,0x31,0x4b,0x00,
+		0x49,0x33,0x4d,0x00,0x4c,0x36,0x51,0x00,0x51,0x3b,0x57,0x00,0x55,0x40,0x5b,0x00,0x59,0x45,0x5f,0x00,0x5e,0x4a,0x64,0x00,
+		0x62,0x4f,0x6a,0x00,0x66,0x55,0x6f,0x00,0x6b,0x5b,0x75,0x00,0x70,0x62,0x7b,0x00,0x75,0x69,0x80,0x00,0x7b,0x72,0x87,0x00,
+		0x7f,0x78,0x8d,0x00,0x84,0x80,0x94,0x00,0x87,0x87,0x98,0x00,0x8c,0x8e,0x9e,0x00,0x90,0x95,0xa3,0x00,0x93,0x9b,0xa8,0x00,
+		0x95,0xa0,0xab,0x00,0x97,0xa5,0xae,0x00,0x99,0xab,0xb2,0x00,0x99,0xad,0xb2,0x00,0x9a,0xb0,0xb4,0x00,0x9a,0xb3,0xb6,0x00,
+		0x9b,0xb6,0xb6,0x00,0x9b,0xb8,0xb7,0x00,0x9e,0xbb,0xb9,0x00,0xc4,0xd6,0xd5,0x00,0xf3,0xf7,0xf6,0x00,0xff,0xff,0xff,0x00,
+		0xf2,0xf6,0xf6,0x00,0xc2,0xd6,0xd2,0x00,0x99,0xba,0xb3,0x00,0x96,0xb7,0xb0,0x00,0x94,0xb5,0xad,0x00,0x92,0xb3,0xab,0x00,
+		0x8f,0xb0,0xa7,0x00,0x8c,0xab,0xa4,0x00,0x8a,0xa7,0xa0,0x00,0x86,0xa3,0x9b,0x00,0x81,0x9c,0x95,0x00,0x7b,0x95,0x8d,0x00,
+		0x75,0x8e,0x87,0x00,0x6f,0x86,0x80,0x00,0x67,0x7d,0x76,0x00,0x5f,0x74,0x6d,0x00,0x57,0x6a,0x65,0x00,0x4e,0x60,0x5b,0x00,
+		0x46,0x57,0x52,0x00,0x3e,0x4d,0x48,0x00,0x35,0x43,0x3f,0x00,0x2f,0x3b,0x37,0x00,0x29,0x33,0x30,0x00,0x24,0x2e,0x2b,0x00,
+		0x25,0x2e,0x2b,0x00,0x2d,0x33,0x31,0x00,0x33,0x39,0x38,0x00,0x34,0x39,0x37,0x00,0x31,0x35,0x34,0x00,0x2f,0x33,0x31,0x00,
+		0x2e,0x31,0x2f,0x00,0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x2a,0x2c,0x2c,0x00,0x2a,0x2c,0x2b,0x00,0x29,0x2a,0x29,0x00,
+		0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0xe2,0xe2,0xe2,0x00,0xb8,0xb8,0xb8,0x00,0x28,0x29,0x29,0x00,0x29,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x53,0x53,0x53,0x00,0xff,0xff,0xff,0x00,0x8c,0x8d,0x8d,0x00,0x53,0x53,0x53,0x00,
+		0xff,0xff,0xff,0x00,0x70,0x70,0x70,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x45,0x45,0x45,0x00,0xff,0xff,0xff,0x00,
+		0x8d,0x8d,0x8d,0x00,0x29,0x29,0x29,0x00,0xff,0xff,0xff,0x00,0x8d,0x8d,0x8d,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,
+		0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x62,0x62,0x62,0x00,0x29,0x29,0x29,0x00,0xff,0xff,0xff,0x00,0x8d,0x8d,0x8d,0x00,
+		0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x62,0x62,0x62,0x00,0x8d,0x8d,0x8d,0x00,
+		0xff,0xff,0xff,0x00,0x53,0x53,0x53,0x00,0x28,0x28,0x29,0x00,0x28,0x28,0x28,0x00,0x29,0x29,0x29,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x53,0x53,0x53,0x00,0xff,0xff,0xff,0x00,0x8c,0x8c,0x8c,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0xc5,0xc5,0xc5,0x00,0xc6,0xc5,0xc5,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0xff,0xff,0xff,0x00,0x8b,0x8b,0x8b,0x00,0x1a,0x19,0x19,0x00,0xff,0xff,0xff,0x00,0x79,0x79,0x79,0x00,
+		0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x67,0x67,0x66,0x00,0xff,0xff,0xff,0x00,0x46,0x45,0x44,0x00,0x36,0x35,0x33,0x00,
+		0xff,0xff,0xff,0x00,0x58,0x58,0x55,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x7a,0x79,0x77,0x00,0xff,0xff,0xff,0x00,
+		0x48,0x48,0x44,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x09,0x06,0x00,0x00,0x09,0x06,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,
+		0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,0x0b,0x09,0x00,0x00,0x0c,0x09,0x00,0x00,
+		0x0b,0x09,0x00,0x00,0x0b,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x09,0x00,0x00,0x0b,0x08,0x00,0x00,0x0b,0x08,0x00,0x00,
+		0x0a,0x08,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x22,0x23,0x00,0x23,0x22,0x23,0x00,0x24,0x24,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x27,0x25,0x27,0x00,
+		0x27,0x26,0x27,0x00,0x28,0x26,0x28,0x00,0x29,0x27,0x2a,0x00,0x2b,0x28,0x2b,0x00,0x2b,0x2a,0x2c,0x00,0x2d,0x2a,0x2e,0x00,
+		0x2f,0x2b,0x2f,0x00,0x31,0x2d,0x31,0x00,0x32,0x2e,0x33,0x00,0x35,0x30,0x36,0x00,0x37,0x31,0x38,0x00,0x37,0x31,0x38,0x00,
+		0x39,0x31,0x3b,0x00,0x3d,0x34,0x3d,0x00,0x3e,0x36,0x3f,0x00,0x41,0x37,0x42,0x00,0x42,0x38,0x44,0x00,0x44,0x3b,0x46,0x00,
+		0x47,0x3c,0x48,0x00,0x47,0x3a,0x49,0x00,0x45,0x37,0x47,0x00,0x3f,0x30,0x41,0x00,0x3a,0x2b,0x3d,0x00,0x38,0x28,0x3b,0x00,
+		0x39,0x28,0x3c,0x00,0x3b,0x29,0x3e,0x00,0x3e,0x2b,0x41,0x00,0x40,0x2d,0x44,0x00,0x44,0x30,0x48,0x00,0x46,0x33,0x4b,0x00,
+		0x4a,0x36,0x4f,0x00,0x4d,0x3a,0x53,0x00,0x51,0x3d,0x57,0x00,0x55,0x42,0x5b,0x00,0x58,0x47,0x60,0x00,0x5c,0x4c,0x64,0x00,
+		0x61,0x52,0x6a,0x00,0x64,0x59,0x6f,0x00,0x6a,0x5f,0x75,0x00,0x6e,0x66,0x7b,0x00,0x74,0x6d,0x81,0x00,0x78,0x74,0x87,0x00,
+		0x7e,0x7d,0x8d,0x00,0x81,0x83,0x92,0x00,0x86,0x8b,0x99,0x00,0x88,0x90,0x9c,0x00,0x8e,0x98,0xa3,0x00,0x90,0x9e,0xa6,0x00,
+		0x93,0xa3,0xaa,0x00,0x95,0xa8,0xac,0x00,0x97,0xac,0xb0,0x00,0x97,0xaf,0xb1,0x00,0x98,0xb1,0xb2,0x00,0x99,0xb4,0xb3,0x00,
+		0x99,0xb6,0xb3,0x00,0x98,0xb6,0xb3,0x00,0x99,0xb7,0xb3,0x00,0x98,0xb7,0xb2,0x00,0x97,0xb7,0xb1,0x00,0x96,0xb6,0xb0,0x00,
+		0x95,0xb5,0xae,0x00,0x93,0xb3,0xac,0x00,0x91,0xb0,0xa9,0x00,0x8f,0xad,0xa6,0x00,0x8b,0xa8,0xa1,0x00,0x87,0xa4,0x9d,0x00,
+		0x82,0x9e,0x96,0x00,0x7d,0x98,0x91,0x00,0x77,0x90,0x89,0x00,0x71,0x88,0x82,0x00,0x69,0x80,0x7a,0x00,0x62,0x77,0x71,0x00,
+		0x59,0x6d,0x68,0x00,0x51,0x64,0x5f,0x00,0x49,0x5a,0x54,0x00,0x41,0x51,0x4c,0x00,0x39,0x47,0x43,0x00,0x32,0x3f,0x3b,0x00,
+		0x2b,0x37,0x33,0x00,0x24,0x2e,0x2b,0x00,0x21,0x2b,0x27,0x00,0x26,0x2e,0x2b,0x00,0x30,0x37,0x34,0x00,0x34,0x3a,0x38,0x00,
+		0x33,0x38,0x36,0x00,0x30,0x35,0x34,0x00,0x2e,0x32,0x30,0x00,0x2d,0x2f,0x2f,0x00,0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,
+		0x29,0x2b,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x2a,0x29,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x6f,0x70,0x70,0x00,0xff,0xff,0xff,0x00,0xb8,0xb8,0xb8,0x00,0x36,0x36,0x36,0x00,0x28,0x28,0x28,0x00,0x61,0x61,0x61,0x00,
+		0xe2,0xe2,0xe2,0x00,0xd4,0xd4,0xd4,0x00,0x29,0x29,0x29,0x00,0x28,0x28,0x28,0x00,0xd4,0xd4,0xd4,0x00,0xe2,0xe2,0xe2,0x00,
+		0x45,0x45,0x45,0x00,0x28,0x28,0x29,0x00,0xc6,0xc6,0xc6,0x00,0xf1,0xf1,0xf1,0x00,0x45,0x45,0x45,0x00,0x29,0x29,0x29,0x00,
+		0xff,0xff,0xff,0x00,0x8d,0x8d,0x8d,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x7e,0x7e,0x7f,0x00,0xff,0xff,0xff,0x00,
+		0x61,0x61,0x62,0x00,0x28,0x28,0x29,0x00,0xff,0xff,0xff,0x00,0x8d,0x8d,0x8d,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,
+		0x7f,0x7f,0x7f,0x00,0xff,0xff,0xff,0x00,0x61,0x61,0x61,0x00,0x36,0x36,0x36,0x00,0xf1,0xf1,0xf1,0x00,0xd4,0xd4,0xd4,0x00,
+		0x36,0x36,0x37,0x00,0x28,0x28,0x28,0x00,0xc6,0xc6,0xc6,0x00,0xf1,0xf1,0xf1,0x00,0x36,0x36,0x36,0x00,0x28,0x28,0x28,0x00,
+		0xd4,0xd4,0xd4,0x00,0xe2,0xe2,0xe2,0x00,0x35,0x35,0x35,0x00,0x45,0x45,0x45,0x00,0xf1,0xf1,0xf1,0x00,0xb7,0xb7,0xb7,0x00,
+		0x27,0x27,0x27,0x00,0xb7,0xb7,0xb7,0x00,0xd4,0xd4,0xd4,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0xff,0xff,0xff,0x00,
+		0x82,0x82,0x81,0x00,0x08,0x08,0x07,0x00,0xff,0xff,0xff,0x00,0x78,0x78,0x77,0x00,0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x67,0x67,0x66,0x00,0xff,0xff,0xff,0x00,0x46,0x45,0x44,0x00,0x03,0x02,0x00,0x00,0xcd,0xcc,0xcc,0x00,0xcd,0xcd,0xcc,0x00,
+		0x15,0x14,0x11,0x00,0x25,0x25,0x22,0x00,0xde,0xde,0xdd,0x00,0xff,0xff,0xff,0x00,0x48,0x47,0x44,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x09,0x06,0x00,0x00,
+		0x09,0x06,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,
+		0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,
+		0x09,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,0x0a,0x07,0x00,0x00,
+		0x0a,0x07,0x00,0x00,0x0a,0x08,0x00,0x00,0x0a,0x08,0x00,0x00,0x0a,0x08,0x00,0x00,0x0a,0x08,0x00,0x00,0x09,0x08,0x00,0x00,
+		0x09,0x08,0x00,0x00,0x09,0x08,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x09,0x07,0x00,0x00,0x08,0x07,0x00,0x00,
+		0x08,0x07,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x06,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x23,0x00,0x23,0x22,0x23,0x00,
+		0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x24,0x24,0x24,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x28,0x26,0x28,0x00,
+		0x2a,0x27,0x2a,0x00,0x2a,0x27,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2d,0x2b,0x2e,0x00,0x2f,0x2c,0x2f,0x00,
+		0x30,0x2c,0x31,0x00,0x33,0x2e,0x34,0x00,0x34,0x2f,0x34,0x00,0x36,0x31,0x37,0x00,0x38,0x31,0x38,0x00,0x3a,0x33,0x3c,0x00,
+		0x3c,0x34,0x3d,0x00,0x3d,0x36,0x3e,0x00,0x41,0x37,0x42,0x00,0x42,0x38,0x44,0x00,0x45,0x3a,0x47,0x00,0x47,0x3c,0x47,0x00,
+		0x48,0x3d,0x4a,0x00,0x4a,0x3d,0x4c,0x00,0x48,0x3c,0x4a,0x00,0x44,0x36,0x46,0x00,0x3e,0x2e,0x40,0x00,0x3a,0x2a,0x3e,0x00,
+		0x3b,0x2a,0x3e,0x00,0x3c,0x2b,0x40,0x00,0x3f,0x2c,0x43,0x00,0x42,0x30,0x46,0x00,0x44,0x32,0x49,0x00,0x45,0x34,0x4a,0x00,
+		0x49,0x38,0x4f,0x00,0x4d,0x3c,0x53,0x00,0x50,0x3f,0x56,0x00,0x53,0x44,0x5b,0x00,0x56,0x49,0x5f,0x00,0x5b,0x4f,0x64,0x00,
+		0x60,0x55,0x6a,0x00,0x63,0x5b,0x6f,0x00,0x68,0x62,0x75,0x00,0x6d,0x6a,0x7b,0x00,0x72,0x71,0x80,0x00,0x76,0x78,0x86,0x00,
+		0x7a,0x7f,0x8c,0x00,0x7f,0x86,0x91,0x00,0x83,0x8d,0x97,0x00,0x87,0x94,0x9b,0x00,0x8a,0x99,0xa0,0x00,0x8e,0xa0,0xa4,0x00,
+		0x90,0xa4,0xa7,0x00,0x93,0xa8,0xaa,0x00,0x93,0xab,0xac,0x00,0x95,0xae,0xae,0x00,0x96,0xb0,0xaf,0x00,0x96,0xb2,0xaf,0x00,
+		0x95,0xb2,0xae,0x00,0x95,0xb2,0xae,0x00,0x95,0xb2,0xad,0x00,0x94,0xb1,0xac,0x00,0x91,0xaf,0xa9,0x00,0x8f,0xac,0xa6,0x00,
+		0x8d,0xa9,0xa3,0x00,0x89,0xa5,0x9f,0x00,0x84,0x9f,0x99,0x00,0x7f,0x99,0x93,0x00,0x7a,0x92,0x8c,0x00,0x73,0x8a,0x85,0x00,
+		0x6b,0x83,0x7c,0x00,0x63,0x79,0x73,0x00,0x5b,0x70,0x6a,0x00,0x54,0x67,0x62,0x00,0x4b,0x5d,0x58,0x00,0x43,0x54,0x4f,0x00,
+		0x3b,0x4a,0x46,0x00,0x34,0x41,0x3d,0x00,0x2d,0x39,0x35,0x00,0x25,0x31,0x2e,0x00,0x20,0x2b,0x28,0x00,0x1f,0x29,0x26,0x00,
+		0x27,0x30,0x2d,0x00,0x32,0x39,0x36,0x00,0x34,0x3a,0x37,0x00,0x30,0x35,0x34,0x00,0x2f,0x34,0x33,0x00,0x2e,0x32,0x30,0x00,
+		0x2c,0x2f,0x2e,0x00,0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2b,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,
+		0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,0x28,0x28,0x28,0x00,0x61,0x61,0x61,0x00,
+		0xd4,0xd4,0xd4,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xa8,0xa9,0xa9,0x00,0x36,0x36,0x36,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x45,0x45,0x45,0x00,0xc6,0xc6,0xc6,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
+		0xd4,0xd4,0xd4,0x00,0x53,0x53,0x53,0x00,0x28,0x28,0x29,0x00,0x28,0x29,0x29,0x00,0xff,0xff,0xff,0x00,0x8c,0x8d,0x8d,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x7e,0x7e,0x7f,0x00,0xff,0xff,0xff,0x00,0x61,0x61,0x62,0x00,0x28,0x28,0x29,0x00,
+		0xff,0xff,0xff,0x00,0x8c,0x8c,0x8c,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x7e,0x7e,0x7e,0x00,0xff,0xff,0xff,0x00,
+		0x61,0x61,0x61,0x00,0x28,0x28,0x28,0x00,0x53,0x53,0x53,0x00,0xd4,0xd4,0xd4,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
+		0xd4,0xd4,0xd4,0x00,0x61,0x61,0x61,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x45,0x45,0x45,0x00,0xd4,0xd4,0xd4,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0xc5,0xc5,0xc5,0x00,0x35,0x35,0x35,0x00,0x27,0x27,0x27,0x00,0x6f,0x6f,0x6f,0x00,
+		0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x2a,0x29,0x29,0x00,0xff,0xff,0xff,0x00,0x7a,0x7a,0x7a,0x00,0x01,0x01,0x00,0x00,
+		0xff,0xff,0xff,0x00,0x78,0x78,0x77,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x67,0x67,0x66,0x00,0xff,0xff,0xff,0x00,
+		0x45,0x45,0x44,0x00,0x03,0x02,0x00,0x00,0x25,0x24,0x22,0x00,0xcd,0xcc,0xcc,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
+		0xbc,0xbc,0xbb,0x00,0xff,0xff,0xff,0x00,0x47,0x46,0x44,0x00,0x04,0x03,0x00,0x00,0x9b,0x9b,0x99,0x00,0xff,0xff,0xff,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0xde,0xde,0xdd,0x00,0xbc,0xbc,0xbb,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0xde,0xde,0xdd,0x00,0xbc,0xbc,0xbb,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x05,0x00,0x00,0x08,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x08,0x05,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x09,0x06,0x00,0x00,0x09,0x06,0x00,0x00,0x09,0x06,0x00,0x00,0x09,0x06,0x00,0x00,0x09,0x06,0x00,0x00,0x08,0x06,0x00,0x00,
+		0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x08,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x07,0x06,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x05,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,0x23,0x22,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x24,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x24,0x25,0x00,0x27,0x25,0x27,0x00,0x28,0x27,0x28,0x00,0x29,0x26,0x29,0x00,
+		0x2a,0x28,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2e,0x2b,0x2e,0x00,0x2f,0x2c,0x2f,0x00,0x31,0x2d,0x32,0x00,
+		0x32,0x2d,0x33,0x00,0x34,0x2f,0x34,0x00,0x36,0x31,0x37,0x00,0x38,0x31,0x38,0x00,0x39,0x33,0x3b,0x00,0x3c,0x34,0x3d,0x00,
+		0x3e,0x37,0x3e,0x00,0x3f,0x37,0x40,0x00,0x42,0x38,0x42,0x00,0x44,0x3a,0x46,0x00,0x46,0x3c,0x47,0x00,0x48,0x3d,0x49,0x00,
+		0x4a,0x3f,0x4c,0x00,0x4c,0x3f,0x4d,0x00,0x4c,0x3f,0x4e,0x00,0x48,0x3b,0x4b,0x00,0x42,0x34,0x45,0x00,0x3e,0x2e,0x40,0x00,
+		0x3d,0x2c,0x40,0x00,0x3e,0x2d,0x40,0x00,0x3f,0x2e,0x43,0x00,0x41,0x31,0x45,0x00,0x44,0x33,0x49,0x00,0x46,0x37,0x4c,0x00,
+		0x48,0x3a,0x4f,0x00,0x4c,0x3e,0x53,0x00,0x4d,0x42,0x56,0x00,0x51,0x46,0x5a,0x00,0x56,0x4d,0x60,0x00,0x59,0x51,0x63,0x00,
+		0x5d,0x57,0x68,0x00,0x62,0x5f,0x6f,0x00,0x65,0x64,0x73,0x00,0x6b,0x6d,0x7a,0x00,0x6f,0x74,0x7f,0x00,0x74,0x7a,0x85,0x00,
+		0x78,0x82,0x8b,0x00,0x7d,0x89,0x90,0x00,0x81,0x8f,0x95,0x00,0x84,0x95,0x99,0x00,0x88,0x9a,0x9d,0x00,0x8b,0xa0,0xa2,0x00,
+		0x8d,0xa3,0xa4,0x00,0x8f,0xa6,0xa6,0x00,0x91,0xa9,0xa7,0x00,0x91,0xab,0xa9,0x00,0x91,0xac,0xa8,0x00,0x91,0xac,0xa8,0x00,
+		0x90,0xab,0xa6,0x00,0x8f,0xaa,0xa5,0x00,0x8c,0xa7,0xa2,0x00,0x89,0xa3,0x9e,0x00,0x86,0x9f,0x9a,0x00,0x82,0x9b,0x95,0x00,
+		0x7b,0x93,0x8d,0x00,0x75,0x8d,0x87,0x00,0x6f,0x85,0x80,0x00,0x67,0x7d,0x77,0x00,0x5f,0x73,0x6e,0x00,0x57,0x6a,0x65,0x00,
+		0x4e,0x61,0x5c,0x00,0x46,0x57,0x52,0x00,0x3d,0x4d,0x49,0x00,0x36,0x44,0x40,0x00,0x2f,0x3c,0x38,0x00,0x28,0x34,0x31,0x00,
+		0x22,0x2d,0x2a,0x00,0x1e,0x28,0x25,0x00,0x20,0x29,0x26,0x00,0x2a,0x32,0x30,0x00,0x32,0x39,0x36,0x00,0x32,0x37,0x35,0x00,
+		0x30,0x35,0x34,0x00,0x2f,0x33,0x31,0x00,0x2d,0x31,0x2f,0x00,0x2c,0x2f,0x2e,0x00,0x2b,0x2e,0x2d,0x00,0x29,0x2c,0x2b,0x00,
+		0x29,0x2b,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x28,0x00,0x27,0x27,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x28,0x00,0x27,0x27,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x21,0x21,0x21,0x00,0x14,0x14,0x14,0x00,
+		0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x68,0x67,0x66,0x00,0xff,0xff,0xff,0x00,
+		0x25,0x24,0x22,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,0x07,0x05,0x00,0x00,
+		0x07,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x05,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x22,0x23,0x00,0x23,0x23,0x23,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x27,0x25,0x27,0x00,0x28,0x26,0x28,0x00,0x29,0x27,0x29,0x00,0x2b,0x29,0x2b,0x00,
+		0x2c,0x2a,0x2c,0x00,0x2d,0x2a,0x2d,0x00,0x2e,0x2b,0x2f,0x00,0x30,0x2c,0x30,0x00,0x31,0x2d,0x31,0x00,0x32,0x2e,0x33,0x00,
+		0x33,0x2f,0x34,0x00,0x35,0x31,0x36,0x00,0x37,0x31,0x38,0x00,0x39,0x33,0x39,0x00,0x3b,0x34,0x3c,0x00,0x3d,0x36,0x3d,0x00,
+		0x3e,0x37,0x3f,0x00,0x41,0x39,0x42,0x00,0x42,0x3a,0x44,0x00,0x45,0x3c,0x47,0x00,0x48,0x3d,0x49,0x00,0x49,0x3f,0x4a,0x00,
+		0x4c,0x41,0x4d,0x00,0x4d,0x42,0x4e,0x00,0x4f,0x43,0x51,0x00,0x4d,0x40,0x50,0x00,0x45,0x38,0x48,0x00,0x40,0x33,0x43,0x00,
+		0x3e,0x2f,0x42,0x00,0x3e,0x2f,0x41,0x00,0x3f,0x31,0x44,0x00,0x41,0x32,0x46,0x00,0x43,0x36,0x49,0x00,0x46,0x39,0x4d,0x00,
+		0x46,0x3c,0x4e,0x00,0x49,0x3f,0x52,0x00,0x4c,0x43,0x55,0x00,0x4f,0x48,0x59,0x00,0x52,0x4d,0x5d,0x00,0x56,0x53,0x63,0x00,
+		0x5a,0x5a,0x68,0x00,0x5e,0x60,0x6d,0x00,0x63,0x67,0x72,0x00,0x67,0x6d,0x77,0x00,0x6c,0x75,0x7d,0x00,0x71,0x7b,0x82,0x00,
+		0x75,0x82,0x88,0x00,0x79,0x88,0x8d,0x00,0x7e,0x8f,0x92,0x00,0x81,0x94,0x95,0x00,0x85,0x99,0x99,0x00,0x87,0x9c,0x9c,0x00,
+		0x89,0x9f,0x9e,0x00,0x8a,0xa1,0x9f,0x00,0x8a,0xa2,0x9f,0x00,0x8a,0xa3,0x9f,0x00,0x89,0xa1,0x9d,0x00,0x87,0xa0,0x9b,0x00,
+		0x84,0x9c,0x98,0x00,0x80,0x98,0x93,0x00,0x7c,0x94,0x8e,0x00,0x76,0x8d,0x88,0x00,0x70,0x86,0x80,0x00,0x69,0x7e,0x79,0x00,
+		0x61,0x75,0x70,0x00,0x59,0x6d,0x68,0x00,0x50,0x62,0x5d,0x00,0x48,0x59,0x55,0x00,0x40,0x50,0x4b,0x00,0x38,0x47,0x43,0x00,
+		0x31,0x3f,0x3b,0x00,0x2a,0x37,0x33,0x00,0x24,0x2f,0x2c,0x00,0x1f,0x2a,0x27,0x00,0x1d,0x27,0x24,0x00,0x24,0x2c,0x29,0x00,
+		0x30,0x37,0x34,0x00,0x34,0x3a,0x38,0x00,0x30,0x36,0x34,0x00,0x2f,0x34,0x32,0x00,0x2e,0x32,0x30,0x00,0x2c,0x30,0x2f,0x00,
+		0x2b,0x2f,0x2e,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x29,0x2a,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x1d,0x1d,0x1d,0x00,0x0d,0x0d,0x0d,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x00,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x34,0x34,0x33,0x00,0xff,0xff,0xff,0x00,0x89,0x88,0x88,0x00,
+		0x02,0x01,0x00,0x00,0x13,0x13,0x11,0x00,0xcc,0xcc,0xcc,0x00,0xcd,0xcc,0xcc,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x04,0x02,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,
+		0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x06,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,
+		0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x25,0x26,0x00,0x27,0x25,0x27,0x00,0x28,0x27,0x28,0x00,0x2a,0x28,0x2a,0x00,0x2a,0x28,0x2a,0x00,0x2b,0x29,0x2b,0x00,
+		0x2c,0x2a,0x2d,0x00,0x2d,0x2b,0x2e,0x00,0x2f,0x2c,0x30,0x00,0x31,0x2d,0x31,0x00,0x32,0x2f,0x32,0x00,0x34,0x30,0x35,0x00,
+		0x35,0x31,0x36,0x00,0x37,0x31,0x38,0x00,0x38,0x33,0x38,0x00,0x3b,0x34,0x3c,0x00,0x3d,0x35,0x3d,0x00,0x3e,0x37,0x3f,0x00,
+		0x40,0x38,0x41,0x00,0x43,0x3a,0x44,0x00,0x44,0x3b,0x45,0x00,0x45,0x3d,0x47,0x00,0x48,0x3e,0x48,0x00,0x4a,0x40,0x4c,0x00,
+		0x4c,0x41,0x4e,0x00,0x4e,0x42,0x4f,0x00,0x4e,0x43,0x51,0x00,0x4e,0x42,0x50,0x00,0x48,0x3a,0x4b,0x00,0x44,0x36,0x47,0x00,
+		0x3f,0x33,0x44,0x00,0x3d,0x30,0x42,0x00,0x3e,0x31,0x44,0x00,0x3f,0x33,0x45,0x00,0x41,0x37,0x48,0x00,0x43,0x3b,0x4b,0x00,
+		0x45,0x3e,0x4d,0x00,0x47,0x40,0x50,0x00,0x49,0x44,0x53,0x00,0x4d,0x4b,0x58,0x00,0x50,0x50,0x5c,0x00,0x53,0x55,0x61,0x00,
+		0x57,0x5b,0x65,0x00,0x5b,0x61,0x6a,0x00,0x60,0x68,0x70,0x00,0x64,0x6e,0x74,0x00,0x69,0x75,0x7a,0x00,0x6e,0x7b,0x7f,0x00,
+		0x72,0x82,0x85,0x00,0x76,0x87,0x89,0x00,0x79,0x8c,0x8d,0x00,0x7d,0x90,0x90,0x00,0x7e,0x94,0x92,0x00,0x80,0x95,0x94,0x00,
+		0x80,0x96,0x93,0x00,0x80,0x96,0x93,0x00,0x7f,0x95,0x91,0x00,0x7c,0x93,0x8f,0x00,0x79,0x8f,0x8b,0x00,0x75,0x8b,0x86,0x00,
+		0x70,0x84,0x80,0x00,0x6a,0x7e,0x7a,0x00,0x63,0x76,0x72,0x00,0x5b,0x6e,0x6a,0x00,0x54,0x65,0x61,0x00,0x4a,0x5b,0x57,0x00,
+		0x43,0x53,0x4e,0x00,0x3b,0x4a,0x47,0x00,0x33,0x41,0x3e,0x00,0x2d,0x3a,0x36,0x00,0x27,0x33,0x2f,0x00,0x21,0x2c,0x28,0x00,
+		0x1c,0x27,0x24,0x00,0x1d,0x26,0x23,0x00,0x28,0x30,0x2e,0x00,0x32,0x39,0x37,0x00,0x31,0x38,0x35,0x00,0x2f,0x34,0x33,0x00,
+		0x2e,0x33,0x31,0x00,0x2d,0x31,0x2f,0x00,0x2c,0x2f,0x2f,0x00,0x2a,0x2e,0x2e,0x00,0x2a,0x2e,0x2d,0x00,0x29,0x2c,0x2b,0x00,
+		0x29,0x2c,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x24,0x24,0x24,0x00,0x16,0x16,0x16,0x00,0x07,0x07,0x07,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x78,0x78,0x77,0x00,0xee,0xee,0xee,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,
+		0xbc,0xbb,0xbb,0x00,0x24,0x23,0x22,0x00,0x02,0x01,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x05,0x04,0x00,0x00,0x05,0x04,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x13,0x13,0x13,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x24,0x23,0x24,0x00,
+		0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x26,0x25,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,
+		0x27,0x25,0x27,0x00,0x28,0x26,0x28,0x00,0x29,0x27,0x29,0x00,0x2b,0x28,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2c,0x2b,0x2d,0x00,
+		0x2e,0x2b,0x2e,0x00,0x2f,0x2c,0x2f,0x00,0x31,0x2e,0x31,0x00,0x31,0x2d,0x32,0x00,0x33,0x30,0x34,0x00,0x35,0x30,0x36,0x00,
+		0x37,0x32,0x37,0x00,0x37,0x32,0x38,0x00,0x39,0x33,0x3a,0x00,0x3b,0x34,0x3c,0x00,0x3e,0x37,0x3e,0x00,0x3f,0x38,0x40,0x00,
+		0x41,0x39,0x43,0x00,0x43,0x3b,0x45,0x00,0x44,0x3c,0x46,0x00,0x47,0x3d,0x48,0x00,0x49,0x3f,0x4a,0x00,0x4a,0x40,0x4c,0x00,
+		0x4c,0x42,0x4e,0x00,0x4e,0x43,0x4f,0x00,0x4f,0x45,0x52,0x00,0x50,0x45,0x52,0x00,0x4c,0x40,0x4f,0x00,0x47,0x3d,0x4a,0x00,
+		0x41,0x36,0x45,0x00,0x3e,0x34,0x43,0x00,0x3e,0x35,0x44,0x00,0x3e,0x36,0x45,0x00,0x3e,0x37,0x46,0x00,0x41,0x3c,0x4a,0x00,
+		0x41,0x3f,0x4b,0x00,0x44,0x42,0x4e,0x00,0x46,0x46,0x52,0x00,0x49,0x4b,0x55,0x00,0x4d,0x50,0x5a,0x00,0x51,0x56,0x5e,0x00,
+		0x54,0x5b,0x62,0x00,0x58,0x61,0x67,0x00,0x5c,0x67,0x6c,0x00,0x60,0x6d,0x71,0x00,0x65,0x74,0x77,0x00,0x69,0x79,0x7b,0x00,
+		0x6c,0x7d,0x7e,0x00,0x70,0x82,0x82,0x00,0x72,0x85,0x84,0x00,0x74,0x87,0x86,0x00,0x73,0x87,0x85,0x00,0x74,0x88,0x85,0x00,
+		0x72,0x86,0x83,0x00,0x70,0x84,0x81,0x00,0x6c,0x80,0x7c,0x00,0x68,0x7b,0x78,0x00,0x61,0x75,0x71,0x00,0x5b,0x6e,0x6a,0x00,
+		0x54,0x66,0x62,0x00,0x4d,0x5d,0x59,0x00,0x44,0x55,0x51,0x00,0x3d,0x4c,0x48,0x00,0x36,0x44,0x40,0x00,0x2f,0x3c,0x38,0x00,
+		0x28,0x34,0x31,0x00,0x22,0x2d,0x2a,0x00,0x1e,0x28,0x25,0x00,0x1c,0x25,0x23,0x00,0x21,0x29,0x27,0x00,0x2c,0x33,0x31,0x00,
+		0x31,0x38,0x35,0x00,0x30,0x36,0x34,0x00,0x2f,0x34,0x33,0x00,0x2d,0x31,0x30,0x00,0x2c,0x30,0x2f,0x00,0x2c,0x2f,0x2f,0x00,
+		0x2a,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2c,0x2a,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,0x27,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,
+		0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,
+		0x1f,0x1f,0x1f,0x00,0x0e,0x0e,0x0e,0x00,0x05,0x05,0x04,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+		0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,
+		0x04,0x03,0x00,0x00,0x04,0x03,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x03,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x22,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x28,0x26,0x28,0x00,
+		0x28,0x26,0x28,0x00,0x29,0x28,0x29,0x00,0x2b,0x28,0x2b,0x00,0x2c,0x29,0x2c,0x00,0x2c,0x2b,0x2c,0x00,0x2d,0x2b,0x2e,0x00,
+		0x2f,0x2d,0x2f,0x00,0x30,0x2c,0x31,0x00,0x31,0x2d,0x31,0x00,0x33,0x2f,0x33,0x00,0x35,0x31,0x36,0x00,0x36,0x32,0x36,0x00,
+		0x38,0x33,0x39,0x00,0x38,0x33,0x38,0x00,0x3b,0x34,0x3c,0x00,0x3d,0x36,0x3d,0x00,0x3e,0x37,0x3f,0x00,0x40,0x38,0x41,0x00,
+		0x42,0x3a,0x43,0x00,0x43,0x3b,0x45,0x00,0x46,0x3e,0x47,0x00,0x48,0x3e,0x49,0x00,0x49,0x3f,0x4a,0x00,0x4a,0x41,0x4c,0x00,
+		0x4c,0x43,0x4f,0x00,0x4d,0x44,0x4f,0x00,0x4f,0x46,0x51,0x00,0x4f,0x46,0x51,0x00,0x4d,0x44,0x50,0x00,0x47,0x3f,0x4d,0x00,
+		0x41,0x39,0x47,0x00,0x3d,0x36,0x43,0x00,0x3c,0x35,0x42,0x00,0x3b,0x36,0x42,0x00,0x3b,0x38,0x44,0x00,0x3d,0x3b,0x46,0x00,
+		0x3e,0x3e,0x48,0x00,0x40,0x41,0x4b,0x00,0x43,0x46,0x4f,0x00,0x45,0x4a,0x52,0x00,0x48,0x4f,0x55,0x00,0x4c,0x54,0x5a,0x00,
+		0x50,0x59,0x5e,0x00,0x53,0x5f,0x62,0x00,0x58,0x64,0x67,0x00,0x5b,0x6a,0x6b,0x00,0x5f,0x6e,0x6f,0x00,0x61,0x71,0x71,0x00,
+		0x64,0x75,0x74,0x00,0x66,0x77,0x76,0x00,0x66,0x78,0x76,0x00,0x65,0x78,0x76,0x00,0x64,0x76,0x73,0x00,0x61,0x74,0x71,0x00,
+		0x5d,0x6f,0x6c,0x00,0x58,0x69,0x66,0x00,0x54,0x64,0x61,0x00,0x4d,0x5d,0x5a,0x00,0x46,0x55,0x52,0x00,0x3e,0x4d,0x4a,0x00,
+		0x38,0x46,0x42,0x00,0x30,0x3e,0x3b,0x00,0x29,0x36,0x33,0x00,0x23,0x2f,0x2c,0x00,0x1f,0x2a,0x27,0x00,0x1a,0x24,0x22,0x00,
+		0x1b,0x24,0x22,0x00,0x24,0x2b,0x29,0x00,0x2f,0x36,0x34,0x00,0x31,0x37,0x35,0x00,0x2f,0x35,0x34,0x00,0x2e,0x32,0x31,0x00,
+		0x2d,0x31,0x30,0x00,0x2c,0x30,0x2f,0x00,0x2b,0x2f,0x2d,0x00,0x2a,0x2e,0x2c,0x00,0x29,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,
+		0x29,0x2b,0x2a,0x00,0x29,0x2b,0x29,0x00,0x29,0x2a,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,
+		0x28,0x29,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x19,0x19,0x19,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,
+		0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x03,0x02,0x00,0x00,0x02,0x02,0x00,0x00,
+		0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,0x27,0x26,0x27,0x00,0x29,0x27,0x29,0x00,
+		0x29,0x27,0x29,0x00,0x2b,0x28,0x2b,0x00,0x2b,0x29,0x2c,0x00,0x2b,0x2a,0x2b,0x00,0x2d,0x2b,0x2d,0x00,0x2f,0x2c,0x2f,0x00,
+		0x2f,0x2d,0x30,0x00,0x31,0x2e,0x31,0x00,0x32,0x2f,0x33,0x00,0x34,0x31,0x35,0x00,0x36,0x32,0x36,0x00,0x37,0x32,0x38,0x00,
+		0x38,0x33,0x39,0x00,0x3a,0x34,0x3b,0x00,0x3b,0x35,0x3c,0x00,0x3e,0x37,0x3e,0x00,0x3e,0x38,0x3f,0x00,0x40,0x38,0x41,0x00,
+		0x43,0x3b,0x44,0x00,0x43,0x3c,0x46,0x00,0x46,0x3e,0x48,0x00,0x47,0x3e,0x49,0x00,0x4a,0x41,0x4b,0x00,0x49,0x41,0x4c,0x00,
+		0x4c,0x44,0x4f,0x00,0x4c,0x44,0x4f,0x00,0x4f,0x47,0x52,0x00,0x4f,0x47,0x52,0x00,0x4d,0x46,0x52,0x00,0x48,0x42,0x4e,0x00,
+		0x41,0x3c,0x47,0x00,0x3c,0x37,0x42,0x00,0x38,0x35,0x3f,0x00,0x38,0x37,0x41,0x00,0x38,0x38,0x42,0x00,0x38,0x3a,0x42,0x00,
+		0x3a,0x3d,0x45,0x00,0x3c,0x40,0x47,0x00,0x3e,0x44,0x4a,0x00,0x41,0x49,0x4e,0x00,0x44,0x4d,0x51,0x00,0x46,0x50,0x54,0x00,
+		0x4a,0x56,0x58,0x00,0x4d,0x5a,0x5c,0x00,0x50,0x5e,0x5f,0x00,0x53,0x62,0x62,0x00,0x54,0x64,0x63,0x00,0x56,0x66,0x65,0x00,
+		0x56,0x66,0x64,0x00,0x56,0x66,0x64,0x00,0x54,0x65,0x63,0x00,0x51,0x61,0x5f,0x00,0x4e,0x5d,0x5a,0x00,0x4a,0x59,0x56,0x00,
+		0x44,0x53,0x50,0x00,0x3e,0x4c,0x4a,0x00,0x38,0x45,0x42,0x00,0x31,0x3e,0x3b,0x00,0x2a,0x37,0x34,0x00,0x25,0x31,0x2e,0x00,
+		0x20,0x2b,0x28,0x00,0x1b,0x26,0x23,0x00,0x1a,0x23,0x20,0x00,0x1e,0x26,0x24,0x00,0x29,0x30,0x2f,0x00,0x32,0x38,0x36,0x00,
+		0x30,0x35,0x34,0x00,0x2f,0x34,0x32,0x00,0x2d,0x31,0x30,0x00,0x2d,0x30,0x2f,0x00,0x2c,0x2f,0x2f,0x00,0x2a,0x2e,0x2e,0x00,
+		0x2a,0x2e,0x2d,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x2a,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x21,0x21,0x21,0x00,
+		0x13,0x13,0x13,0x00,0x05,0x05,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,
+		0x02,0x01,0x00,0x00,0x02,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x24,0x25,0x00,0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,0x28,0x26,0x28,0x00,0x28,0x27,0x28,0x00,0x29,0x27,0x29,0x00,
+		0x2a,0x28,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2b,0x2c,0x00,0x2c,0x2b,0x2d,0x00,0x2e,0x2c,0x2f,0x00,0x30,0x2e,0x30,0x00,
+		0x30,0x2c,0x31,0x00,0x32,0x2e,0x32,0x00,0x33,0x2f,0x33,0x00,0x34,0x31,0x35,0x00,0x36,0x32,0x37,0x00,0x38,0x32,0x38,0x00,
+		0x38,0x33,0x39,0x00,0x3a,0x34,0x3b,0x00,0x3c,0x36,0x3d,0x00,0x3e,0x37,0x3e,0x00,0x3e,0x38,0x3f,0x00,0x40,0x39,0x42,0x00,
+		0x42,0x3b,0x44,0x00,0x43,0x3d,0x46,0x00,0x45,0x3e,0x48,0x00,0x48,0x40,0x4a,0x00,0x49,0x42,0x4b,0x00,0x4a,0x43,0x4c,0x00,
+		0x4b,0x44,0x4e,0x00,0x4c,0x45,0x50,0x00,0x4d,0x47,0x50,0x00,0x4d,0x48,0x51,0x00,0x4b,0x46,0x50,0x00,0x47,0x43,0x4c,0x00,
+		0x3f,0x3e,0x46,0x00,0x39,0x38,0x41,0x00,0x33,0x33,0x3b,0x00,0x34,0x35,0x3d,0x00,0x34,0x37,0x3e,0x00,0x35,0x39,0x3f,0x00,
+		0x36,0x3b,0x40,0x00,0x38,0x3f,0x43,0x00,0x3a,0x42,0x46,0x00,0x3b,0x45,0x48,0x00,0x3e,0x48,0x4b,0x00,0x41,0x4c,0x4d,0x00,
+		0x43,0x4f,0x50,0x00,0x44,0x51,0x52,0x00,0x47,0x54,0x53,0x00,0x47,0x55,0x54,0x00,0x47,0x56,0x54,0x00,0x46,0x55,0x53,0x00,
+		0x45,0x53,0x51,0x00,0x43,0x51,0x4e,0x00,0x3f,0x4d,0x4b,0x00,0x3b,0x49,0x46,0x00,0x36,0x44,0x41,0x00,0x31,0x3e,0x3b,0x00,
+		0x2c,0x37,0x35,0x00,0x26,0x32,0x2f,0x00,0x21,0x2b,0x29,0x00,0x1c,0x26,0x24,0x00,0x19,0x22,0x20,0x00,0x1a,0x23,0x21,0x00,
+		0x21,0x29,0x27,0x00,0x2d,0x33,0x31,0x00,0x30,0x36,0x34,0x00,0x2f,0x34,0x32,0x00,0x2e,0x32,0x31,0x00,0x2d,0x31,0x30,0x00,
+		0x2c,0x2f,0x2f,0x00,0x2b,0x2f,0x2e,0x00,0x2a,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,
+		0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,
+		0x26,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x27,0x27,0x00,
+		0x26,0x26,0x27,0x00,0x26,0x26,0x27,0x00,0x26,0x26,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x0d,0x0d,0x0d,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x23,0x24,0x00,0x24,0x23,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x24,0x25,0x00,0x26,0x25,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x26,0x27,0x00,0x28,0x26,0x28,0x00,0x29,0x27,0x29,0x00,0x2a,0x28,0x2a,0x00,
+		0x2b,0x28,0x2b,0x00,0x2c,0x29,0x2c,0x00,0x2d,0x2b,0x2d,0x00,0x2d,0x2b,0x2d,0x00,0x2f,0x2c,0x2f,0x00,0x30,0x2d,0x30,0x00,
+		0x31,0x2e,0x32,0x00,0x33,0x2f,0x33,0x00,0x33,0x30,0x34,0x00,0x35,0x31,0x36,0x00,0x37,0x32,0x38,0x00,0x38,0x33,0x39,0x00,
+		0x39,0x35,0x3a,0x00,0x3b,0x35,0x3c,0x00,0x3d,0x38,0x3e,0x00,0x3e,0x38,0x3e,0x00,0x40,0x3a,0x41,0x00,0x42,0x3b,0x44,0x00,
+		0x42,0x3c,0x43,0x00,0x44,0x3e,0x46,0x00,0x45,0x3f,0x48,0x00,0x45,0x3f,0x48,0x00,0x48,0x41,0x4a,0x00,0x49,0x43,0x4c,0x00,
+		0x4a,0x44,0x4c,0x00,0x4a,0x45,0x4e,0x00,0x4a,0x46,0x4f,0x00,0x4a,0x48,0x50,0x00,0x4b,0x49,0x50,0x00,0x46,0x45,0x4c,0x00,
+		0x3e,0x3d,0x45,0x00,0x37,0x38,0x3f,0x00,0x31,0x33,0x3a,0x00,0x2f,0x33,0x38,0x00,0x2e,0x33,0x38,0x00,0x30,0x36,0x3a,0x00,
+		0x31,0x38,0x3b,0x00,0x32,0x3a,0x3d,0x00,0x33,0x3d,0x3f,0x00,0x34,0x3f,0x40,0x00,0x37,0x41,0x42,0x00,0x39,0x44,0x45,0x00,
+		0x39,0x45,0x45,0x00,0x39,0x45,0x45,0x00,0x39,0x45,0x44,0x00,0x38,0x45,0x44,0x00,0x36,0x43,0x41,0x00,0x34,0x40,0x3e,0x00,
+		0x31,0x3e,0x3b,0x00,0x2e,0x3a,0x38,0x00,0x29,0x35,0x33,0x00,0x25,0x30,0x2e,0x00,0x21,0x2b,0x29,0x00,0x1c,0x26,0x24,0x00,
+		0x18,0x22,0x20,0x00,0x17,0x20,0x1e,0x00,0x1c,0x24,0x22,0x00,0x26,0x2d,0x2b,0x00,0x2e,0x34,0x33,0x00,0x30,0x35,0x34,0x00,
+		0x2e,0x33,0x31,0x00,0x2d,0x31,0x30,0x00,0x2d,0x30,0x2f,0x00,0x2c,0x2f,0x2e,0x00,0x2a,0x2e,0x2e,0x00,0x2a,0x2e,0x2d,0x00,
+		0x29,0x2c,0x2b,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x2a,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x28,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x17,0x17,0x17,0x00,
+		0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x23,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x24,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,0x28,0x26,0x28,0x00,0x29,0x27,0x29,0x00,0x29,0x28,0x29,0x00,0x2a,0x28,0x2a,0x00,
+		0x2b,0x2a,0x2b,0x00,0x2c,0x2b,0x2c,0x00,0x2d,0x2c,0x2d,0x00,0x2e,0x2c,0x2f,0x00,0x30,0x2d,0x30,0x00,0x31,0x2d,0x31,0x00,
+		0x32,0x2f,0x32,0x00,0x33,0x2f,0x33,0x00,0x35,0x31,0x35,0x00,0x36,0x32,0x36,0x00,0x37,0x32,0x38,0x00,0x38,0x34,0x39,0x00,
+		0x39,0x34,0x39,0x00,0x3a,0x35,0x3c,0x00,0x3c,0x37,0x3e,0x00,0x3e,0x38,0x3e,0x00,0x3f,0x3a,0x40,0x00,0x41,0x3b,0x42,0x00,
+		0x42,0x3c,0x44,0x00,0x43,0x3e,0x45,0x00,0x44,0x3f,0x47,0x00,0x45,0x40,0x48,0x00,0x46,0x42,0x49,0x00,0x46,0x43,0x4a,0x00,
+		0x47,0x44,0x4b,0x00,0x48,0x45,0x4c,0x00,0x48,0x45,0x4c,0x00,0x49,0x47,0x4e,0x00,0x46,0x46,0x4c,0x00,0x42,0x43,0x48,0x00,
+		0x3b,0x3d,0x41,0x00,0x34,0x37,0x3c,0x00,0x2d,0x31,0x36,0x00,0x2b,0x30,0x34,0x00,0x2a,0x31,0x34,0x00,0x2a,0x32,0x34,0x00,
+		0x2b,0x33,0x35,0x00,0x2b,0x34,0x36,0x00,0x2e,0x37,0x38,0x00,0x2d,0x37,0x38,0x00,0x2e,0x38,0x38,0x00,0x2d,0x37,0x37,0x00,
+		0x2c,0x37,0x37,0x00,0x2b,0x37,0x36,0x00,0x2a,0x35,0x34,0x00,0x28,0x33,0x32,0x00,0x25,0x2f,0x2e,0x00,0x23,0x2d,0x2b,0x00,
+		0x1f,0x29,0x27,0x00,0x1c,0x26,0x24,0x00,0x19,0x21,0x20,0x00,0x16,0x1e,0x1d,0x00,0x17,0x1e,0x1e,0x00,0x20,0x27,0x26,0x00,
+		0x2b,0x31,0x30,0x00,0x2f,0x34,0x34,0x00,0x2f,0x34,0x33,0x00,0x2e,0x32,0x31,0x00,0x2d,0x30,0x2f,0x00,0x2b,0x2f,0x2f,0x00,
+		0x2b,0x2f,0x2e,0x00,0x2a,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2b,0x2a,0x00,
+		0x29,0x2a,0x2a,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,0x11,0x11,0x11,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x00,
+		0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,0x29,0x27,0x29,0x00,0x2b,0x29,0x2b,0x00,0x2b,0x29,0x2b,0x00,
+		0x2b,0x2a,0x2c,0x00,0x2d,0x2b,0x2d,0x00,0x2d,0x2b,0x2d,0x00,0x2f,0x2d,0x2f,0x00,0x30,0x2d,0x30,0x00,0x31,0x2d,0x32,0x00,
+		0x32,0x2f,0x32,0x00,0x33,0x30,0x33,0x00,0x34,0x31,0x35,0x00,0x36,0x32,0x37,0x00,0x37,0x32,0x38,0x00,0x38,0x34,0x39,0x00,
+		0x39,0x34,0x39,0x00,0x3a,0x36,0x3c,0x00,0x3c,0x37,0x3e,0x00,0x3e,0x39,0x3f,0x00,0x3f,0x3a,0x40,0x00,0x40,0x3c,0x42,0x00,
+		0x41,0x3c,0x43,0x00,0x42,0x3e,0x44,0x00,0x44,0x40,0x46,0x00,0x44,0x40,0x47,0x00,0x44,0x41,0x48,0x00,0x45,0x43,0x49,0x00,
+		0x45,0x44,0x4a,0x00,0x45,0x45,0x4a,0x00,0x45,0x45,0x4b,0x00,0x45,0x46,0x4b,0x00,0x44,0x45,0x4b,0x00,0x40,0x43,0x46,0x00,
+		0x39,0x3d,0x41,0x00,0x32,0x36,0x38,0x00,0x2a,0x2f,0x32,0x00,0x25,0x2c,0x2e,0x00,0x25,0x2b,0x2d,0x00,0x23,0x2b,0x2c,0x00,
+		0x24,0x2c,0x2d,0x00,0x24,0x2d,0x2e,0x00,0x23,0x2c,0x2c,0x00,0x24,0x2d,0x2d,0x00,0x22,0x2b,0x2b,0x00,0x22,0x2b,0x2b,0x00,
+		0x20,0x29,0x28,0x00,0x1e,0x27,0x26,0x00,0x1b,0x24,0x23,0x00,0x1a,0x22,0x21,0x00,0x17,0x20,0x1e,0x00,0x16,0x1e,0x1c,0x00,
+		0x16,0x1d,0x1b,0x00,0x1a,0x22,0x20,0x00,0x27,0x2d,0x2b,0x00,0x2f,0x34,0x33,0x00,0x2f,0x34,0x33,0x00,0x2e,0x32,0x31,0x00,
+		0x2d,0x31,0x30,0x00,0x2d,0x30,0x2f,0x00,0x2b,0x2f,0x2e,0x00,0x2a,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,
+		0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2b,0x00,0x29,0x2a,0x29,0x00,0x29,0x2a,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1b,0x1b,0x1b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x23,0x24,0x00,
+		0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x27,0x26,0x27,0x00,0x29,0x27,0x29,0x00,0x28,0x28,0x28,0x00,0x2a,0x28,0x2a,0x00,0x2a,0x28,0x2a,0x00,0x2b,0x2a,0x2b,0x00,
+		0x2d,0x2a,0x2d,0x00,0x2d,0x2b,0x2d,0x00,0x2e,0x2c,0x2e,0x00,0x2f,0x2d,0x2f,0x00,0x31,0x2d,0x31,0x00,0x31,0x2e,0x31,0x00,
+		0x32,0x2f,0x32,0x00,0x33,0x30,0x34,0x00,0x35,0x32,0x35,0x00,0x36,0x32,0x37,0x00,0x38,0x34,0x39,0x00,0x38,0x34,0x39,0x00,
+		0x38,0x35,0x39,0x00,0x3b,0x37,0x3d,0x00,0x3c,0x38,0x3e,0x00,0x3e,0x39,0x3f,0x00,0x3e,0x3a,0x3f,0x00,0x3f,0x3b,0x41,0x00,
+		0x3f,0x3c,0x42,0x00,0x40,0x3d,0x43,0x00,0x40,0x3e,0x44,0x00,0x41,0x3f,0x44,0x00,0x41,0x3f,0x44,0x00,0x42,0x41,0x46,0x00,
+		0x41,0x41,0x46,0x00,0x41,0x42,0x46,0x00,0x42,0x44,0x47,0x00,0x41,0x43,0x47,0x00,0x41,0x44,0x46,0x00,0x3d,0x3f,0x42,0x00,
+		0x36,0x3a,0x3d,0x00,0x2d,0x33,0x35,0x00,0x24,0x2a,0x2c,0x00,0x21,0x27,0x28,0x00,0x1d,0x25,0x25,0x00,0x1d,0x25,0x25,0x00,
+		0x1c,0x24,0x24,0x00,0x1c,0x24,0x24,0x00,0x1a,0x23,0x22,0x00,0x1a,0x22,0x21,0x00,0x18,0x20,0x1f,0x00,0x17,0x1f,0x1e,0x00,
+		0x16,0x1d,0x1c,0x00,0x13,0x1b,0x1a,0x00,0x13,0x1b,0x19,0x00,0x17,0x1d,0x1b,0x00,0x20,0x26,0x25,0x00,0x2b,0x31,0x30,0x00,
+		0x2e,0x33,0x32,0x00,0x2e,0x32,0x31,0x00,0x2e,0x31,0x30,0x00,0x2c,0x2f,0x2f,0x00,0x2c,0x2f,0x2e,0x00,0x2b,0x2e,0x2e,0x00,
+		0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,
+		0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x28,0x27,0x28,0x00,
+		0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,0x2a,0x28,0x2a,0x00,0x29,0x28,0x29,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2a,0x2c,0x00,
+		0x2c,0x2b,0x2c,0x00,0x2d,0x2b,0x2d,0x00,0x2e,0x2c,0x2e,0x00,0x30,0x2d,0x30,0x00,0x31,0x2e,0x31,0x00,0x31,0x2e,0x32,0x00,
+		0x32,0x2f,0x33,0x00,0x33,0x30,0x33,0x00,0x34,0x31,0x35,0x00,0x36,0x33,0x37,0x00,0x38,0x34,0x39,0x00,0x39,0x35,0x3a,0x00,
+		0x39,0x36,0x3a,0x00,0x3a,0x37,0x3b,0x00,0x3b,0x38,0x3d,0x00,0x3c,0x39,0x3e,0x00,0x3d,0x39,0x3f,0x00,0x3d,0x3a,0x3f,0x00,
+		0x3f,0x3c,0x41,0x00,0x3f,0x3d,0x42,0x00,0x40,0x3f,0x43,0x00,0x40,0x3f,0x43,0x00,0x3f,0x3f,0x43,0x00,0x3f,0x3f,0x43,0x00,
+		0x3f,0x40,0x44,0x00,0x3f,0x3f,0x42,0x00,0x3e,0x40,0x43,0x00,0x3f,0x41,0x44,0x00,0x3d,0x40,0x42,0x00,0x39,0x3d,0x3f,0x00,
+		0x32,0x37,0x38,0x00,0x28,0x2e,0x2f,0x00,0x1f,0x25,0x26,0x00,0x1a,0x21,0x21,0x00,0x16,0x1d,0x1d,0x00,0x17,0x1e,0x1d,0x00,
+		0x15,0x1c,0x1c,0x00,0x15,0x1c,0x1b,0x00,0x13,0x1a,0x19,0x00,0x12,0x19,0x18,0x00,0x12,0x18,0x18,0x00,0x13,0x1a,0x19,0x00,
+		0x18,0x1e,0x1d,0x00,0x24,0x29,0x28,0x00,0x2c,0x32,0x31,0x00,0x2f,0x32,0x32,0x00,0x2e,0x31,0x31,0x00,0x2d,0x30,0x2f,0x00,
+		0x2c,0x2f,0x2f,0x00,0x2b,0x2f,0x2e,0x00,0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2b,0x00,
+		0x29,0x2b,0x2a,0x00,0x29,0x2a,0x29,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1e,0x1e,0x1e,0x00,0x10,0x10,0x10,0x00,0x05,0x05,0x05,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x27,0x28,0x00,
+		0x28,0x27,0x28,0x00,0x29,0x28,0x29,0x00,0x2a,0x28,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x29,0x2c,0x00,0x2c,0x2a,0x2d,0x00,
+		0x2d,0x2b,0x2d,0x00,0x2d,0x2c,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x31,0x2e,0x31,0x00,0x31,0x2e,0x32,0x00,0x31,0x2e,0x32,0x00,
+		0x32,0x2f,0x33,0x00,0x33,0x31,0x34,0x00,0x35,0x32,0x36,0x00,0x37,0x33,0x37,0x00,0x37,0x34,0x38,0x00,0x38,0x35,0x39,0x00,
+		0x39,0x36,0x3a,0x00,0x3a,0x37,0x3b,0x00,0x39,0x37,0x3b,0x00,0x3a,0x38,0x3c,0x00,0x3b,0x3a,0x3e,0x00,0x3c,0x3a,0x3f,0x00,
+		0x3c,0x3a,0x3f,0x00,0x3b,0x3b,0x3f,0x00,0x3d,0x3d,0x40,0x00,0x3c,0x3d,0x3f,0x00,0x3c,0x3d,0x40,0x00,0x3c,0x3d,0x40,0x00,
+		0x3b,0x3d,0x40,0x00,0x3b,0x3e,0x40,0x00,0x3a,0x3d,0x3f,0x00,0x3a,0x3d,0x3f,0x00,0x39,0x3d,0x3e,0x00,0x36,0x3a,0x3b,0x00,
+		0x2e,0x32,0x33,0x00,0x24,0x28,0x29,0x00,0x19,0x1e,0x1e,0x00,0x14,0x1a,0x1a,0x00,0x12,0x18,0x18,0x00,0x10,0x16,0x16,0x00,
+		0x10,0x15,0x15,0x00,0x0f,0x14,0x14,0x00,0x14,0x19,0x18,0x00,0x1d,0x22,0x21,0x00,0x2a,0x2e,0x2d,0x00,0x2f,0x33,0x32,0x00,
+		0x2e,0x31,0x31,0x00,0x2c,0x30,0x2f,0x00,0x2c,0x2f,0x2f,0x00,0x2b,0x2f,0x2e,0x00,0x2a,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,
+		0x29,0x2c,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2b,0x00,0x29,0x2a,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,
+		0x1a,0x1a,0x1a,0x00,0x0b,0x0b,0x0b,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x24,0x25,0x00,0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x28,0x27,0x28,0x00,
+		0x29,0x27,0x29,0x00,0x29,0x28,0x29,0x00,0x2a,0x28,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2c,0x2a,0x2d,0x00,
+		0x2d,0x2b,0x2d,0x00,0x2d,0x2c,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x30,0x2e,0x30,0x00,0x31,0x2e,0x32,0x00,0x32,0x2f,0x33,0x00,
+		0x32,0x2f,0x32,0x00,0x34,0x32,0x34,0x00,0x35,0x33,0x36,0x00,0x36,0x33,0x37,0x00,0x36,0x33,0x37,0x00,0x37,0x34,0x39,0x00,
+		0x38,0x35,0x39,0x00,0x38,0x36,0x39,0x00,0x39,0x37,0x3a,0x00,0x39,0x37,0x3a,0x00,0x3a,0x39,0x3c,0x00,0x3a,0x3a,0x3c,0x00,
+		0x3a,0x3a,0x3d,0x00,0x3a,0x3a,0x3d,0x00,0x3a,0x3a,0x3d,0x00,0x3a,0x3a,0x3d,0x00,0x39,0x3a,0x3c,0x00,0x39,0x3a,0x3d,0x00,
+		0x38,0x3a,0x3c,0x00,0x38,0x3a,0x3b,0x00,0x36,0x3a,0x3a,0x00,0x35,0x39,0x3a,0x00,0x35,0x3a,0x3a,0x00,0x33,0x37,0x37,0x00,
+		0x2a,0x2f,0x2f,0x00,0x20,0x25,0x25,0x00,0x16,0x19,0x19,0x00,0x11,0x15,0x15,0x00,0x12,0x16,0x16,0x00,0x18,0x1c,0x1c,0x00,
+		0x25,0x29,0x28,0x00,0x2d,0x31,0x30,0x00,0x2e,0x31,0x31,0x00,0x2d,0x30,0x2f,0x00,0x2c,0x2f,0x2f,0x00,0x2b,0x2f,0x2e,0x00,
+		0x2b,0x2e,0x2d,0x00,0x2a,0x2d,0x2c,0x00,0x2a,0x2c,0x2c,0x00,0x2a,0x2c,0x2c,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,
+		0x29,0x2a,0x2a,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x24,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,
+		0x29,0x27,0x29,0x00,0x2a,0x29,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2c,0x2b,0x2d,0x00,
+		0x2e,0x2c,0x2e,0x00,0x2d,0x2d,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x30,0x2d,0x30,0x00,0x31,0x2f,0x32,0x00,0x32,0x2f,0x33,0x00,
+		0x33,0x30,0x33,0x00,0x33,0x31,0x34,0x00,0x33,0x32,0x34,0x00,0x34,0x33,0x36,0x00,0x35,0x33,0x37,0x00,0x35,0x34,0x37,0x00,
+		0x36,0x34,0x38,0x00,0x36,0x35,0x39,0x00,0x37,0x36,0x39,0x00,0x38,0x37,0x3a,0x00,0x38,0x38,0x3a,0x00,0x38,0x38,0x3a,0x00,
+		0x37,0x38,0x3a,0x00,0x37,0x38,0x3a,0x00,0x37,0x38,0x3a,0x00,0x37,0x38,0x3a,0x00,0x36,0x38,0x39,0x00,0x36,0x38,0x39,0x00,
+		0x34,0x38,0x39,0x00,0x34,0x37,0x38,0x00,0x34,0x36,0x37,0x00,0x33,0x36,0x37,0x00,0x32,0x35,0x36,0x00,0x2e,0x33,0x33,0x00,
+		0x28,0x2c,0x2c,0x00,0x23,0x26,0x26,0x00,0x25,0x2a,0x29,0x00,0x2c,0x2f,0x2f,0x00,0x2d,0x30,0x2f,0x00,0x2d,0x30,0x2f,0x00,
+		0x2c,0x2f,0x2f,0x00,0x2c,0x2f,0x2e,0x00,0x2b,0x2e,0x2e,0x00,0x2b,0x2e,0x2d,0x00,0x2a,0x2c,0x2c,0x00,0x29,0x2c,0x2b,0x00,
+		0x29,0x2b,0x2b,0x00,0x29,0x2b,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1e,0x1e,0x1e,0x00,
+		0x10,0x10,0x10,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x26,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,
+		0x29,0x28,0x29,0x00,0x2a,0x28,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2d,0x2b,0x2d,0x00,0x2d,0x2c,0x2e,0x00,
+		0x2e,0x2c,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x2f,0x2e,0x2f,0x00,0x30,0x2e,0x31,0x00,0x30,0x2e,0x31,0x00,0x31,0x2f,0x32,0x00,
+		0x32,0x30,0x32,0x00,0x32,0x31,0x33,0x00,0x33,0x31,0x34,0x00,0x33,0x32,0x34,0x00,0x33,0x33,0x34,0x00,0x33,0x33,0x35,0x00,
+		0x35,0x35,0x37,0x00,0x35,0x35,0x38,0x00,0x34,0x34,0x36,0x00,0x34,0x34,0x37,0x00,0x34,0x34,0x37,0x00,0x35,0x36,0x38,0x00,
+		0x34,0x36,0x37,0x00,0x34,0x35,0x37,0x00,0x34,0x36,0x37,0x00,0x34,0x35,0x36,0x00,0x33,0x35,0x36,0x00,0x32,0x34,0x35,0x00,
+		0x32,0x34,0x34,0x00,0x31,0x34,0x34,0x00,0x31,0x34,0x34,0x00,0x33,0x36,0x36,0x00,0x3a,0x3d,0x3d,0x00,0x42,0x45,0x45,0x00,
+		0x42,0x44,0x44,0x00,0x3a,0x3c,0x3c,0x00,0x32,0x35,0x35,0x00,0x2e,0x31,0x30,0x00,0x2d,0x2f,0x2f,0x00,0x2b,0x2e,0x2d,0x00,
+		0x2a,0x2d,0x2c,0x00,0x29,0x2c,0x2b,0x00,0x29,0x2b,0x2b,0x00,0x29,0x2b,0x2b,0x00,0x29,0x2a,0x2a,0x00,0x29,0x2a,0x2a,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1b,0x1b,0x1b,0x00,0x0b,0x0b,0x0b,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x25,0x25,0x25,0x00,0x27,0x26,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,
+		0x29,0x29,0x29,0x00,0x2a,0x28,0x2a,0x00,0x2b,0x2a,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2d,0x2c,0x2d,0x00,0x2d,0x2c,0x2e,0x00,
+		0x2e,0x2c,0x2e,0x00,0x2e,0x2d,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x2f,0x2e,0x30,0x00,0x30,0x2e,0x31,0x00,0x31,0x2f,0x32,0x00,
+		0x31,0x2f,0x32,0x00,0x31,0x30,0x33,0x00,0x32,0x31,0x33,0x00,0x32,0x31,0x33,0x00,0x33,0x32,0x33,0x00,0x34,0x34,0x35,0x00,
+		0x32,0x32,0x33,0x00,0x33,0x34,0x35,0x00,0x33,0x34,0x35,0x00,0x33,0x34,0x35,0x00,0x33,0x34,0x34,0x00,0x32,0x34,0x34,0x00,
+		0x32,0x34,0x34,0x00,0x31,0x33,0x34,0x00,0x31,0x34,0x34,0x00,0x30,0x33,0x33,0x00,0x30,0x32,0x33,0x00,0x32,0x34,0x34,0x00,
+		0x35,0x38,0x38,0x00,0x40,0x41,0x41,0x00,0x49,0x4b,0x4b,0x00,0x4d,0x4e,0x4e,0x00,0x4c,0x4e,0x4e,0x00,0x4a,0x4c,0x4c,0x00,
+		0x41,0x44,0x44,0x00,0x38,0x3b,0x3a,0x00,0x30,0x32,0x32,0x00,0x2c,0x2e,0x2e,0x00,0x2a,0x2c,0x2b,0x00,0x29,0x2b,0x2b,0x00,
+		0x29,0x2a,0x2a,0x00,0x29,0x2a,0x2a,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x16,0x16,0x16,0x00,
+		0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,
+		0x27,0x26,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x28,0x27,0x28,0x00,0x29,0x28,0x29,0x00,
+		0x29,0x29,0x29,0x00,0x2b,0x29,0x2b,0x00,0x2b,0x2a,0x2b,0x00,0x2c,0x2a,0x2c,0x00,0x2d,0x2b,0x2d,0x00,0x2d,0x2c,0x2d,0x00,
+		0x2d,0x2c,0x2e,0x00,0x2e,0x2d,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x2f,0x2e,0x30,0x00,0x2f,0x2e,0x30,0x00,
+		0x30,0x2f,0x31,0x00,0x30,0x2f,0x31,0x00,0x31,0x31,0x33,0x00,0x31,0x31,0x33,0x00,0x31,0x31,0x33,0x00,0x31,0x31,0x33,0x00,
+		0x31,0x31,0x33,0x00,0x31,0x32,0x33,0x00,0x31,0x32,0x33,0x00,0x30,0x31,0x33,0x00,0x30,0x31,0x32,0x00,0x30,0x32,0x32,0x00,
+		0x2f,0x31,0x31,0x00,0x2f,0x32,0x32,0x00,0x33,0x34,0x34,0x00,0x3a,0x3c,0x3c,0x00,0x46,0x48,0x48,0x00,0x4b,0x4d,0x4d,0x00,
+		0x4c,0x4e,0x4e,0x00,0x4b,0x4d,0x4d,0x00,0x4b,0x4d,0x4c,0x00,0x4b,0x4c,0x4c,0x00,0x4a,0x4b,0x4b,0x00,0x48,0x4a,0x4a,0x00,
+		0x41,0x42,0x41,0x00,0x36,0x37,0x37,0x00,0x2d,0x2e,0x2e,0x00,0x2a,0x2b,0x2b,0x00,0x29,0x29,0x29,0x00,0x28,0x29,0x29,0x00,
+		0x28,0x29,0x29,0x00,0x28,0x29,0x29,0x00,0x28,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x28,0x28,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x10,0x10,0x10,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x26,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x28,0x27,0x28,0x00,0x28,0x27,0x28,0x00,
+		0x2a,0x29,0x2a,0x00,0x2b,0x29,0x2b,0x00,0x2b,0x2a,0x2b,0x00,0x2b,0x2a,0x2c,0x00,0x2c,0x2b,0x2c,0x00,0x2c,0x2b,0x2d,0x00,
+		0x2d,0x2c,0x2d,0x00,0x2d,0x2c,0x2e,0x00,0x2e,0x2d,0x2e,0x00,0x2e,0x2d,0x2e,0x00,0x2e,0x2e,0x2e,0x00,0x2f,0x2f,0x30,0x00,
+		0x2e,0x2e,0x2f,0x00,0x2f,0x2e,0x2f,0x00,0x2f,0x2f,0x2f,0x00,0x2f,0x2f,0x31,0x00,0x2f,0x2f,0x31,0x00,0x2f,0x2f,0x30,0x00,
+		0x2f,0x30,0x30,0x00,0x2f,0x30,0x30,0x00,0x2f,0x30,0x30,0x00,0x2f,0x30,0x31,0x00,0x31,0x32,0x32,0x00,0x38,0x39,0x39,0x00,
+		0x41,0x43,0x43,0x00,0x4a,0x4b,0x4b,0x00,0x4b,0x4d,0x4d,0x00,0x4b,0x4d,0x4d,0x00,0x4b,0x4d,0x4d,0x00,0x4b,0x4c,0x4c,0x00,
+		0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x49,0x4b,0x4b,0x00,0x49,0x4b,0x4b,0x00,0x49,0x4a,0x4a,0x00,0x47,0x48,0x48,0x00,
+		0x40,0x40,0x40,0x00,0x34,0x35,0x35,0x00,0x2c,0x2d,0x2d,0x00,0x29,0x2a,0x2a,0x00,0x28,0x29,0x29,0x00,0x27,0x28,0x28,0x00,
+		0x27,0x28,0x28,0x00,0x27,0x28,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1c,0x1c,0x1c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x28,0x27,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x29,0x28,0x29,0x00,0x29,0x28,0x29,0x00,
+		0x2a,0x29,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2b,0x2a,0x2b,0x00,0x2b,0x2a,0x2b,0x00,0x2b,0x2a,0x2c,0x00,0x2c,0x2b,0x2c,0x00,
+		0x2c,0x2c,0x2d,0x00,0x2c,0x2c,0x2d,0x00,0x2d,0x2d,0x2d,0x00,0x2d,0x2d,0x2e,0x00,0x2d,0x2d,0x2e,0x00,0x2d,0x2d,0x2e,0x00,
+		0x2e,0x2e,0x2f,0x00,0x2e,0x2e,0x2f,0x00,0x2e,0x2e,0x2f,0x00,0x2e,0x2f,0x2f,0x00,0x2e,0x2f,0x2f,0x00,0x2e,0x2e,0x2f,0x00,
+		0x2f,0x2f,0x30,0x00,0x34,0x35,0x36,0x00,0x3e,0x3f,0x3f,0x00,0x46,0x48,0x48,0x00,0x4b,0x4b,0x4c,0x00,0x4b,0x4c,0x4d,0x00,
+		0x4b,0x4b,0x4c,0x00,0x4b,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x49,0x4b,0x4b,0x00,0x49,0x4b,0x4b,0x00,
+		0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x46,0x47,0x47,0x00,
+		0x3f,0x40,0x40,0x00,0x32,0x33,0x33,0x00,0x2a,0x2b,0x2b,0x00,0x28,0x29,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x17,0x17,0x17,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,
+		0x28,0x27,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x29,0x28,0x29,0x00,0x29,0x28,0x29,0x00,
+		0x2a,0x28,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2b,0x2a,0x2b,0x00,0x2b,0x2a,0x2b,0x00,0x2b,0x2a,0x2b,0x00,
+		0x2b,0x2b,0x2c,0x00,0x2b,0x2b,0x2c,0x00,0x2b,0x2b,0x2c,0x00,0x2d,0x2d,0x2e,0x00,0x2d,0x2d,0x2e,0x00,0x2c,0x2c,0x2d,0x00,
+		0x2d,0x2d,0x2e,0x00,0x2d,0x2d,0x2e,0x00,0x2e,0x2e,0x2f,0x00,0x31,0x31,0x32,0x00,0x3a,0x3a,0x3a,0x00,0x43,0x43,0x44,0x00,
+		0x49,0x4a,0x4b,0x00,0x4b,0x4b,0x4b,0x00,0x4b,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,
+		0x49,0x4b,0x4b,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,
+		0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x45,0x46,0x46,0x00,
+		0x3c,0x3c,0x3c,0x00,0x31,0x31,0x31,0x00,0x2a,0x2a,0x2a,0x00,0x28,0x28,0x28,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x21,0x21,0x21,0x00,0x11,0x11,0x11,0x00,0x04,0x04,0x04,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x28,0x27,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x29,0x28,0x29,0x00,
+		0x29,0x28,0x29,0x00,0x29,0x29,0x29,0x00,0x2a,0x29,0x2a,0x00,0x29,0x29,0x2a,0x00,0x2a,0x29,0x2a,0x00,0x2a,0x2a,0x2b,0x00,
+		0x2b,0x2a,0x2b,0x00,0x2b,0x2b,0x2c,0x00,0x2b,0x2b,0x2c,0x00,0x2b,0x2b,0x2c,0x00,0x2c,0x2c,0x2d,0x00,0x2f,0x2f,0x2f,0x00,
+		0x34,0x34,0x35,0x00,0x3f,0x3f,0x40,0x00,0x47,0x48,0x48,0x00,0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,0x4a,0x4b,0x4b,0x00,
+		0x4a,0x4b,0x4b,0x00,0x49,0x4b,0x4b,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,
+		0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x48,0x48,0x00,
+		0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x43,0x43,0x43,0x00,
+		0x3b,0x3b,0x3b,0x00,0x30,0x30,0x30,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x1c,0x1c,0x1c,0x00,0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x26,0x00,0x26,0x25,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,
+		0x29,0x28,0x29,0x00,0x29,0x29,0x29,0x00,0x29,0x28,0x29,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,0x2a,0x2a,0x2a,0x00,
+		0x2a,0x2a,0x2b,0x00,0x2a,0x2b,0x2b,0x00,0x30,0x31,0x31,0x00,0x3a,0x3b,0x3b,0x00,0x45,0x45,0x45,0x00,0x4a,0x4b,0x4b,0x00,
+		0x4a,0x4a,0x4b,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x4a,0x4a,0x00,0x49,0x49,0x49,0x00,
+		0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x49,0x49,0x00,
+		0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x45,0x45,0x45,0x00,0x42,0x42,0x42,0x00,
+		0x3a,0x3a,0x3a,0x00,0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x18,0x18,0x18,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x25,0x26,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x29,0x29,0x29,0x00,
+		0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x2a,0x2a,0x2a,0x00,0x2e,0x2e,0x2e,0x00,0x36,0x36,0x37,0x00,
+		0x41,0x41,0x41,0x00,0x48,0x48,0x49,0x00,0x49,0x49,0x4a,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,
+		0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,
+		0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x48,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,
+		0x37,0x37,0x37,0x00,0x2e,0x2e,0x2e,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,
+		0x13,0x13,0x13,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0d,0x0d,0x0d,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,0x27,0x26,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x28,0x28,0x28,0x00,0x29,0x29,0x29,0x00,0x28,0x28,0x28,0x00,0x29,0x29,0x29,0x00,
+		0x2b,0x2b,0x2b,0x00,0x33,0x33,0x33,0x00,0x3f,0x3f,0x3f,0x00,0x46,0x46,0x46,0x00,0x48,0x48,0x48,0x00,0x49,0x49,0x49,0x00,
+		0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x49,0x49,0x49,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x48,0x49,0x49,0x00,
+		0x49,0x49,0x49,0x00,0x49,0x49,0x49,0x00,0x48,0x49,0x49,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x47,0x48,0x48,0x00,
+		0x47,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3f,0x3f,0x3f,0x00,
+		0x34,0x34,0x34,0x00,0x2b,0x2b,0x2b,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x0d,0x0d,0x0d,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,
+		0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x26,0x27,0x00,0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,
+		0x27,0x27,0x27,0x00,0x27,0x27,0x27,0x00,0x2a,0x2a,0x2a,0x00,0x2e,0x2e,0x2e,0x00,0x3a,0x3a,0x3a,0x00,0x44,0x44,0x44,0x00,
+		0x47,0x47,0x47,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x49,0x49,0x49,0x00,0x48,0x48,0x48,0x00,
+		0x49,0x49,0x49,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x48,0x48,0x48,0x00,
+		0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,0x3c,0x3c,0x3c,0x00,
+		0x31,0x31,0x31,0x00,0x29,0x29,0x29,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x19,0x19,0x19,0x00,
+		0x0a,0x0a,0x0a,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x2c,0x2c,0x2d,0x00,
+		0x36,0x35,0x36,0x00,0x40,0x40,0x40,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x48,0x48,0x48,0x00,0x47,0x47,0x47,0x00,0x48,0x48,0x48,0x00,
+		0x47,0x48,0x48,0x00,0x47,0x48,0x48,0x00,0x47,0x47,0x48,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,0x3a,0x3a,0x3a,0x00,
+		0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0f,0x0f,0x0f,0x00,0x15,0x15,0x15,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x27,0x27,0x27,0x00,0x2a,0x2a,0x2a,0x00,0x33,0x33,0x33,0x00,0x3d,0x3d,0x3d,0x00,0x44,0x44,0x44,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,
+		0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x42,0x42,0x42,0x00,0x38,0x38,0x38,0x00,
+		0x2e,0x2e,0x2e,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1e,0x1e,0x1e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,
+		0x08,0x08,0x08,0x00,0x0d,0x0d,0x0d,0x00,0x14,0x14,0x14,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x29,0x29,0x29,0x00,0x2f,0x2f,0x2f,0x00,0x3a,0x3a,0x3a,0x00,
+		0x44,0x44,0x44,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,0x35,0x35,0x35,0x00,
+		0x2c,0x2c,0x2c,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x24,0x24,0x24,0x00,0x19,0x19,0x19,0x00,0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0e,0x0e,0x0e,0x00,0x15,0x15,0x15,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x28,0x28,0x28,0x00,
+		0x2e,0x2e,0x2e,0x00,0x38,0x38,0x38,0x00,0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x47,0x47,0x47,0x00,0x47,0x47,0x47,0x00,
+		0x47,0x47,0x47,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3e,0x3e,0x3e,0x00,0x33,0x33,0x33,0x00,
+		0x2b,0x2b,0x2b,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x08,0x08,0x08,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x10,0x10,0x10,0x00,0x17,0x17,0x17,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x27,0x27,0x27,0x00,0x2c,0x2c,0x2c,0x00,0x35,0x35,0x35,0x00,0x3f,0x3f,0x3f,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x43,0x43,0x43,0x00,0x3a,0x3a,0x3a,0x00,0x30,0x30,0x30,0x00,
+		0x29,0x29,0x29,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x1e,0x1e,0x1e,0x00,0x10,0x10,0x10,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,0x10,0x10,0x10,0x00,0x17,0x17,0x17,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x27,0x27,0x27,0x00,0x2c,0x2c,0x2c,0x00,0x33,0x33,0x33,0x00,
+		0x3e,0x3e,0x3e,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,0x36,0x36,0x36,0x00,0x2d,0x2d,0x2d,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x19,0x19,0x19,0x00,0x0c,0x0c,0x0c,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x13,0x13,0x13,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1e,0x1e,0x1e,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x2a,0x2a,0x2a,0x00,0x32,0x32,0x32,0x00,0x3e,0x3e,0x3e,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3f,0x3f,0x3f,0x00,0x33,0x33,0x33,0x00,0x29,0x29,0x29,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,
+		0x15,0x15,0x15,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0d,0x0d,0x0d,0x00,
+		0x15,0x15,0x15,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x2a,0x2a,0x2a,0x00,0x32,0x32,0x32,0x00,0x3a,0x3a,0x3a,0x00,0x42,0x42,0x42,0x00,
+		0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3c,0x3c,0x3c,0x00,0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x1e,0x1e,0x1e,0x00,0x0f,0x0f,0x0f,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,
+		0x11,0x11,0x11,0x00,0x18,0x18,0x18,0x00,0x1d,0x1d,0x1d,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x2a,0x2a,0x2a,0x00,0x32,0x32,0x32,0x00,
+		0x3a,0x3a,0x3a,0x00,0x40,0x40,0x40,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x42,0x42,0x42,0x00,0x38,0x38,0x38,0x00,0x2d,0x2d,0x2d,0x00,0x28,0x28,0x28,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x18,0x18,0x18,0x00,
+		0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x0c,0x0c,0x0c,0x00,0x14,0x14,0x14,0x00,0x1b,0x1b,0x1b,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,
+		0x29,0x29,0x29,0x00,0x31,0x31,0x31,0x00,0x3a,0x3a,0x3a,0x00,0x40,0x40,0x40,0x00,0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,
+		0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3f,0x3f,0x3f,0x00,0x34,0x34,0x34,0x00,0x2b,0x2b,0x2b,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0d,0x0d,0x0d,0x00,0x16,0x16,0x16,0x00,0x1e,0x1e,0x1e,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x29,0x29,0x29,0x00,0x30,0x30,0x30,0x00,0x38,0x38,0x38,0x00,0x3f,0x3f,0x3f,0x00,
+		0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x43,0x43,0x43,0x00,0x3a,0x3a,0x3a,0x00,0x2f,0x2f,0x2f,0x00,0x1f,0x1f,0x1f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,0x12,0x12,0x12,0x00,0x1e,0x1e,0x1e,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x27,0x27,0x27,0x00,0x2e,0x2e,0x2e,0x00,
+		0x38,0x38,0x38,0x00,0x3f,0x3f,0x3f,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,
+		0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x43,0x43,0x43,0x00,0x31,0x31,0x31,0x00,0x19,0x19,0x19,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,0x0e,0x0e,0x0e,0x00,0x19,0x19,0x19,0x00,0x20,0x20,0x20,0x00,0x23,0x23,0x23,0x00,
+		0x26,0x26,0x26,0x00,0x2c,0x2c,0x2c,0x00,0x36,0x36,0x36,0x00,0x3f,0x3f,0x3f,0x00,0x42,0x42,0x42,0x00,0x41,0x41,0x41,0x00,
+		0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,
+		0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3f,0x3f,0x3f,0x00,0x31,0x31,0x31,0x00,0x29,0x29,0x29,0x00,
+		0x25,0x25,0x25,0x00,0x1c,0x1c,0x1c,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0f,0x0f,0x0f,0x00,0x1f,0x1f,0x1f,0x00,0x31,0x31,0x31,0x00,0x3c,0x3c,0x3c,0x00,
+		0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,
+		0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,
+		0x3a,0x3a,0x3a,0x00,0x2d,0x2d,0x2d,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x23,0x23,0x23,0x00,0x17,0x17,0x17,0x00,0x0a,0x0a,0x0a,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,
+		0x17,0x17,0x17,0x00,0x23,0x23,0x23,0x00,0x2b,0x2b,0x2b,0x00,0x33,0x33,0x33,0x00,0x3c,0x3c,0x3c,0x00,0x40,0x40,0x40,0x00,
+		0x41,0x41,0x41,0x00,0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,
+		0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x41,0x41,0x41,0x00,0x34,0x34,0x34,0x00,0x2a,0x2a,0x2a,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x1e,0x1e,0x1e,0x00,0x12,0x12,0x12,0x00,0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x0e,0x0e,0x0e,0x00,0x17,0x17,0x17,0x00,0x20,0x20,0x20,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x29,0x29,0x29,0x00,0x30,0x30,0x30,0x00,0x38,0x38,0x38,0x00,0x3e,0x3e,0x3e,0x00,
+		0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,
+		0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,0x3b,0x3b,0x3b,0x00,
+		0x2f,0x2f,0x2f,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,
+		0x18,0x18,0x18,0x00,0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0e,0x0e,0x0e,0x00,0x19,0x19,0x19,0x00,0x21,0x21,0x21,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x25,0x25,0x25,0x00,0x28,0x28,0x28,0x00,0x2e,0x2e,0x2e,0x00,0x36,0x36,0x36,0x00,0x3e,0x3e,0x3e,0x00,
+		0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x41,0x41,0x41,0x00,0x36,0x36,0x36,0x00,0x2c,0x2c,0x2c,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,
+		0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x10,0x10,0x10,0x00,
+		0x1a,0x1a,0x1a,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x27,0x27,0x27,0x00,0x2c,0x2c,0x2c,0x00,0x36,0x36,0x36,0x00,0x3d,0x3d,0x3d,0x00,
+		0x42,0x42,0x42,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3d,0x3d,0x3d,0x00,0x31,0x31,0x31,0x00,
+		0x29,0x29,0x29,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1b,0x1b,0x1b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x08,0x08,0x08,0x00,0x12,0x12,0x12,0x00,0x1b,0x1b,0x1b,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x27,0x27,0x27,0x00,0x2d,0x2d,0x2d,0x00,0x34,0x34,0x34,0x00,0x3d,0x3d,0x3d,0x00,
+		0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x43,0x43,0x43,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x42,0x42,0x42,0x00,0x37,0x37,0x37,0x00,0x2d,0x2d,0x2d,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,
+		0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x12,0x12,0x12,0x00,0x1c,0x1c,0x1c,0x00,0x20,0x20,0x20,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x2b,0x2b,0x2b,0x00,0x32,0x32,0x32,0x00,0x3a,0x3a,0x3a,0x00,
+		0x41,0x41,0x41,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,
+		0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3c,0x3c,0x3c,0x00,0x30,0x30,0x30,0x00,0x29,0x29,0x29,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1b,0x1b,0x1b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,0x14,0x14,0x14,0x00,
+		0x1d,0x1d,0x1d,0x00,0x20,0x20,0x20,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x27,0x27,0x27,0x00,0x2a,0x2a,0x2a,0x00,0x32,0x32,0x32,0x00,0x3a,0x3a,0x3a,0x00,
+		0x41,0x41,0x41,0x00,0x42,0x42,0x42,0x00,0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,
+		0x44,0x44,0x44,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,
+		0x35,0x35,0x35,0x00,0x2c,0x2c,0x2c,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x21,0x21,0x21,0x00,0x14,0x14,0x14,0x00,0x08,0x08,0x08,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,
+		0x0e,0x0e,0x0e,0x00,0x17,0x17,0x17,0x00,0x1d,0x1d,0x1d,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x29,0x29,0x29,0x00,0x30,0x30,0x30,0x00,0x39,0x39,0x39,0x00,
+		0x40,0x40,0x40,0x00,0x43,0x43,0x43,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,0x3c,0x3c,0x3c,0x00,0x30,0x30,0x30,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x0f,0x0f,0x0f,0x00,0x04,0x04,0x04,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x0b,0x0b,0x0b,0x00,0x12,0x12,0x12,0x00,0x1a,0x1a,0x1a,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x29,0x29,0x29,0x00,0x2f,0x2f,0x2f,0x00,0x38,0x38,0x38,0x00,
+		0x41,0x41,0x41,0x00,0x43,0x43,0x43,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x41,0x41,0x41,0x00,0x36,0x36,0x36,0x00,
+		0x2c,0x2c,0x2c,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x17,0x17,0x17,0x00,0x0a,0x0a,0x0a,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,0x0d,0x0d,0x0d,0x00,0x14,0x14,0x14,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1e,0x1e,0x1e,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2f,0x2f,0x2f,0x00,0x39,0x39,0x39,0x00,
+		0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x44,0x44,0x44,0x00,0x3a,0x3a,0x3a,0x00,0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1d,0x1d,0x1d,0x00,0x0f,0x0f,0x0f,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x10,0x10,0x10,0x00,
+		0x17,0x17,0x17,0x00,0x1c,0x1c,0x1c,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2f,0x2f,0x2f,0x00,0x39,0x39,0x39,0x00,
+		0x40,0x40,0x40,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3f,0x3f,0x3f,0x00,0x34,0x34,0x34,0x00,0x2b,0x2b,0x2b,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x0a,0x0a,0x0a,0x00,0x12,0x12,0x12,0x00,0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2f,0x2f,0x2f,0x00,0x39,0x39,0x39,0x00,
+		0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x43,0x43,0x43,0x00,
+		0x3a,0x3a,0x3a,0x00,0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0e,0x0e,0x0e,0x00,0x16,0x16,0x16,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2e,0x2e,0x2e,0x00,0x39,0x39,0x39,0x00,
+		0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,0x33,0x33,0x33,0x00,0x2a,0x2a,0x2a,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x22,0x22,0x22,0x00,0x15,0x15,0x15,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0a,0x0a,0x0a,0x00,0x11,0x11,0x11,0x00,0x17,0x17,0x17,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x29,0x29,0x29,0x00,0x2e,0x2e,0x2e,0x00,0x39,0x39,0x39,0x00,
+		0x41,0x41,0x41,0x00,0x44,0x44,0x44,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x43,0x43,0x43,0x00,0x39,0x39,0x39,0x00,
+		0x2d,0x2d,0x2d,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,
+		0x1b,0x1b,0x1b,0x00,0x0d,0x0d,0x0d,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0d,0x0d,0x0d,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2f,0x2f,0x2f,0x00,0x39,0x39,0x39,0x00,
+		0x42,0x42,0x42,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x44,0x44,0x44,0x00,0x3b,0x3b,0x3b,0x00,0x30,0x30,0x30,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x20,0x20,0x20,0x00,
+		0x13,0x13,0x13,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x0b,0x0b,0x0b,0x00,0x11,0x11,0x11,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2e,0x2e,0x2e,0x00,0x39,0x39,0x39,0x00,
+		0x43,0x43,0x43,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3e,0x3e,0x3e,0x00,0x34,0x34,0x34,0x00,0x2b,0x2b,0x2b,0x00,
+		0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1a,0x1a,0x1a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x27,0x27,0x27,0x00,0x28,0x28,0x28,0x00,0x30,0x30,0x30,0x00,0x3b,0x3b,0x3b,0x00,
+		0x43,0x43,0x43,0x00,0x45,0x45,0x45,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x42,0x42,0x42,0x00,
+		0x38,0x38,0x38,0x00,0x2f,0x2f,0x2f,0x00,0x29,0x29,0x29,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x20,0x20,0x20,0x00,0x13,0x13,0x13,0x00,
+		0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0d,0x0d,0x0d,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x2a,0x2a,0x2a,0x00,0x32,0x32,0x32,0x00,0x3c,0x3c,0x3c,0x00,
+		0x43,0x43,0x43,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x3c,0x3c,0x3c,0x00,0x31,0x31,0x31,0x00,0x29,0x29,0x29,0x00,0x27,0x27,0x27,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x18,0x18,0x18,0x00,0x0a,0x0a,0x0a,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x28,0x28,0x28,0x00,0x2b,0x2b,0x2b,0x00,0x34,0x34,0x34,0x00,0x3e,0x3e,0x3e,0x00,
+		0x44,0x44,0x44,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,
+		0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x45,0x45,0x45,0x00,0x40,0x40,0x40,0x00,0x34,0x34,0x34,0x00,
+		0x2b,0x2b,0x2b,0x00,0x27,0x27,0x27,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1e,0x1e,0x1e,0x00,0x0f,0x0f,0x0f,0x00,0x04,0x04,0x04,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,
+		0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x29,0x29,0x29,0x00,0x2d,0x2d,0x2d,0x00,0x36,0x36,0x36,0x00,0x3f,0x3f,0x3f,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,0x46,0x46,0x46,0x00,
+		0x42,0x42,0x42,0x00,0x38,0x38,0x38,0x00,0x2d,0x2d,0x2d,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x16,0x16,0x16,0x00,0x08,0x08,0x08,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x29,0x29,0x29,0x00,0x2f,0x2f,0x2f,0x00,0x38,0x38,0x38,0x00,0x41,0x41,0x41,0x00,
+		0x45,0x45,0x45,0x00,0x46,0x46,0x46,0x00,0x44,0x44,0x44,0x00,0x3a,0x3a,0x3a,0x00,0x30,0x30,0x30,0x00,0x29,0x29,0x29,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x1c,0x1c,0x1c,0x00,0x0c,0x0c,0x0c,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x27,0x27,0x27,0x00,0x29,0x29,0x29,0x00,0x2f,0x2f,0x2f,0x00,0x39,0x39,0x39,0x00,0x3b,0x3b,0x3b,0x00,
+		0x32,0x32,0x32,0x00,0x2b,0x2b,0x2b,0x00,0x28,0x28,0x28,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x1d,0x1d,0x1d,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x24,0x24,0x24,0x00,0x18,0x18,0x18,0x00,0x0a,0x0a,0x0a,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x21,0x21,0x21,0x00,0x17,0x17,0x17,0x00,0x0b,0x0b,0x0b,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,0x1d,0x1d,0x1d,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x1e,0x1e,0x1e,0x00,0x0f,0x0f,0x0f,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,
+		0x1a,0x1a,0x1a,0x00,0x0c,0x0c,0x0c,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x12,0x12,0x12,0x00,0x1f,0x1f,0x1f,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,
+		0x14,0x14,0x14,0x00,0x08,0x08,0x08,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1c,0x1c,0x1c,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,0x16,0x16,0x16,0x00,0x21,0x21,0x21,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1a,0x1a,0x1a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x10,0x10,0x10,0x00,
+		0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0e,0x0e,0x0e,0x00,0x1a,0x1a,0x1a,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x11,0x11,0x11,0x00,
+		0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x1f,0x1f,0x1f,0x00,0x12,0x12,0x12,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x11,0x11,0x11,0x00,0x1e,0x1e,0x1e,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x17,0x17,0x17,0x00,0x09,0x09,0x09,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x20,0x20,0x20,0x00,0x15,0x15,0x15,0x00,0x0a,0x0a,0x0a,0x00,0x03,0x03,0x03,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x15,0x15,0x15,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1c,0x1c,0x1c,0x00,0x0d,0x0d,0x0d,0x00,0x03,0x03,0x03,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x1f,0x1f,0x1f,0x00,0x17,0x17,0x17,0x00,
+		0x0c,0x0c,0x0c,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,0x1a,0x1a,0x1a,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x12,0x12,0x12,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x20,0x20,0x20,0x00,0x18,0x18,0x18,0x00,0x0d,0x0d,0x0d,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x0f,0x0f,0x0f,0x00,0x1d,0x1d,0x1d,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x18,0x18,0x18,0x00,0x09,0x09,0x09,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x21,0x21,0x21,0x00,0x19,0x19,0x19,0x00,0x0e,0x0e,0x0e,0x00,0x06,0x06,0x06,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x08,0x08,0x08,0x00,0x14,0x14,0x14,0x00,0x20,0x20,0x20,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x1c,0x1c,0x1c,0x00,0x0d,0x0d,0x0d,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x21,0x21,0x21,0x00,0x18,0x18,0x18,0x00,
+		0x0e,0x0e,0x0e,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,
+		0x0e,0x0e,0x0e,0x00,0x1a,0x1a,0x1a,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x20,0x20,0x20,0x00,0x11,0x11,0x11,0x00,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x22,0x22,0x22,0x00,0x19,0x19,0x19,0x00,0x0e,0x0e,0x0e,0x00,0x06,0x06,0x06,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,
+		0x12,0x12,0x12,0x00,0x1f,0x1f,0x1f,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,
+		0x17,0x17,0x17,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x22,0x22,0x22,0x00,0x1a,0x1a,0x1a,0x00,0x0e,0x0e,0x0e,0x00,0x05,0x05,0x05,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x09,0x09,0x09,0x00,
+		0x17,0x17,0x17,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1b,0x1b,0x1b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x22,0x22,0x22,0x00,0x1a,0x1a,0x1a,0x00,
+		0x0e,0x0e,0x0e,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x0d,0x0d,0x0d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x22,0x22,0x22,0x00,0x1a,0x1a,0x1a,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x13,0x13,0x13,0x00,
+		0x1f,0x1f,0x1f,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x14,0x14,0x14,0x00,0x06,0x06,0x06,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x20,0x20,0x20,0x00,0x18,0x18,0x18,0x00,0x0d,0x0d,0x0d,0x00,0x05,0x05,0x05,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0d,0x0d,0x0d,0x00,0x1a,0x1a,0x1a,0x00,
+		0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1a,0x1a,0x1a,0x00,0x09,0x09,0x09,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x1f,0x1f,0x1f,0x00,0x16,0x16,0x16,0x00,
+		0x0b,0x0b,0x0b,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x12,0x12,0x12,0x00,0x20,0x20,0x20,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x1e,0x1e,0x1e,0x00,0x0d,0x0d,0x0d,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x1e,0x1e,0x1e,0x00,0x14,0x14,0x14,0x00,0x09,0x09,0x09,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0a,0x0a,0x0a,0x00,0x19,0x19,0x19,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x22,0x22,0x22,0x00,0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x1d,0x1d,0x1d,0x00,0x12,0x12,0x12,0x00,0x08,0x08,0x08,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x19,0x19,0x19,0x00,0x09,0x09,0x09,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x1c,0x1c,0x1c,0x00,0x10,0x10,0x10,0x00,
+		0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x0a,0x0a,0x0a,0x00,0x17,0x17,0x17,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x1d,0x1d,0x1d,0x00,0x0d,0x0d,0x0d,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x1a,0x1a,0x1a,0x00,0x0e,0x0e,0x0e,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x06,0x06,0x06,0x00,0x11,0x11,0x11,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x21,0x21,0x21,0x00,
+		0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x1f,0x1f,0x1f,0x00,0x17,0x17,0x17,0x00,0x0c,0x0c,0x0c,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x09,0x09,0x09,0x00,0x16,0x16,0x16,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x18,0x18,0x18,0x00,
+		0x0a,0x0a,0x0a,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x20,0x20,0x20,0x00,0x1c,0x1c,0x1c,0x00,0x13,0x13,0x13,0x00,0x09,0x09,0x09,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x0e,0x0e,0x0e,0x00,0x1c,0x1c,0x1c,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x1d,0x1d,0x1d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x1f,0x1f,0x1f,0x00,0x19,0x19,0x19,0x00,
+		0x10,0x10,0x10,0x00,0x08,0x08,0x08,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x09,0x09,0x09,0x00,0x16,0x16,0x16,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x20,0x20,0x20,0x00,0x12,0x12,0x12,0x00,0x07,0x07,0x07,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x20,0x20,0x20,0x00,
+		0x1c,0x1c,0x1c,0x00,0x15,0x15,0x15,0x00,0x0c,0x0c,0x0c,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,
+		0x0f,0x0f,0x0f,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x23,0x23,0x23,0x00,0x18,0x18,0x18,0x00,0x0a,0x0a,0x0a,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x1f,0x1f,0x1f,0x00,0x1a,0x1a,0x1a,0x00,0x14,0x14,0x14,0x00,0x0b,0x0b,0x0b,0x00,0x04,0x04,0x04,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x09,0x09,0x09,0x00,
+		0x18,0x18,0x18,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x24,0x24,0x24,0x00,0x1c,0x1c,0x1c,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1d,0x1d,0x1d,0x00,0x17,0x17,0x17,0x00,0x0f,0x0f,0x0f,0x00,
+		0x07,0x07,0x07,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,
+		0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x24,0x24,0x24,0x00,0x20,0x20,0x20,0x00,0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1a,0x1a,0x1a,0x00,
+		0x13,0x13,0x13,0x00,0x0b,0x0b,0x0b,0x00,0x06,0x06,0x06,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x0b,0x0b,0x0b,0x00,0x18,0x18,0x18,0x00,
+		0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x23,0x23,0x23,0x00,0x17,0x17,0x17,0x00,0x09,0x09,0x09,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1c,0x1c,0x1c,0x00,0x14,0x14,0x14,0x00,0x0d,0x0d,0x0d,0x00,0x07,0x07,0x07,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x13,0x13,0x13,0x00,0x20,0x20,0x20,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x1d,0x1d,0x1d,0x00,0x0e,0x0e,0x0e,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1a,0x1a,0x1a,0x00,0x11,0x11,0x11,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0c,0x0c,0x0c,0x00,0x1a,0x1a,0x1a,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x20,0x20,0x20,0x00,
+		0x13,0x13,0x13,0x00,0x05,0x05,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x14,0x14,0x14,0x00,0x0b,0x0b,0x0b,0x00,
+		0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x13,0x13,0x13,0x00,0x20,0x20,0x20,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x23,0x23,0x23,0x00,0x19,0x19,0x19,0x00,
+		0x09,0x09,0x09,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x19,0x19,0x19,0x00,0x14,0x14,0x14,0x00,
+		0x0f,0x0f,0x0f,0x00,0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0d,0x0d,0x0d,0x00,0x1c,0x1c,0x1c,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,0x10,0x10,0x10,0x00,
+		0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x17,0x17,0x17,0x00,0x10,0x10,0x10,0x00,0x0a,0x0a,0x0a,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x16,0x16,0x16,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x23,0x23,0x23,0x00,0x16,0x16,0x16,0x00,0x07,0x07,0x07,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,0x0b,0x0b,0x0b,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x04,0x04,0x04,0x00,0x0e,0x0e,0x0e,0x00,0x1f,0x1f,0x1f,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x1c,0x1c,0x1c,0x00,0x0d,0x0d,0x0d,0x00,0x04,0x04,0x04,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,0x0b,0x0b,0x0b,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x08,0x08,0x08,0x00,0x19,0x19,0x19,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x21,0x21,0x21,0x00,0x12,0x12,0x12,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x11,0x11,0x11,0x00,0x0c,0x0c,0x0c,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x05,0x05,0x00,
+		0x13,0x13,0x13,0x00,0x21,0x21,0x21,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x1a,0x1a,0x1a,0x00,0x0c,0x0c,0x0c,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,
+		0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x10,0x10,0x10,0x00,
+		0x0b,0x0b,0x0b,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0d,0x0d,0x0d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x1f,0x1f,0x1f,0x00,0x11,0x11,0x11,0x00,0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x10,0x10,0x10,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x17,0x17,0x17,0x00,
+		0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x22,0x22,0x22,0x00,0x17,0x17,0x17,0x00,0x0b,0x0b,0x0b,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x11,0x11,0x11,0x00,0x1f,0x1f,0x1f,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x23,0x23,0x23,0x00,
+		0x1e,0x1e,0x1e,0x00,0x11,0x11,0x11,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0c,0x0c,0x0c,0x00,0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x22,0x22,0x22,0x00,
+		0x19,0x19,0x19,0x00,0x0a,0x0a,0x0a,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x08,0x08,0x08,0x00,0x15,0x15,0x15,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x23,0x23,0x23,0x00,0x1e,0x1e,0x1e,0x00,
+		0x12,0x12,0x12,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x16,0x16,0x16,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x21,0x21,0x21,0x00,0x18,0x18,0x18,0x00,
+		0x0a,0x0a,0x0a,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x1b,0x1b,0x1b,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x06,0x06,0x06,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,0x1a,0x1a,0x1a,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x1e,0x1e,0x1e,0x00,0x11,0x11,0x11,0x00,
+		0x07,0x07,0x07,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x12,0x12,0x12,0x00,
+		0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,0x1c,0x1c,0x1c,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x08,0x08,0x08,0x00,0x15,0x15,0x15,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x22,0x22,0x22,0x00,0x19,0x19,0x19,0x00,0x0c,0x0c,0x0c,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1b,0x1b,0x1b,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,
+		0x10,0x10,0x10,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x22,0x22,0x22,0x00,0x1f,0x1f,0x1f,0x00,0x13,0x13,0x13,0x00,0x07,0x07,0x07,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x15,0x15,0x15,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x21,0x21,0x21,0x00,0x19,0x19,0x19,0x00,0x0d,0x0d,0x0d,0x00,0x04,0x04,0x04,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1d,0x1d,0x1d,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,
+		0x0d,0x0d,0x0d,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x08,0x08,0x08,0x00,0x16,0x16,0x16,0x00,
+		0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x1e,0x1e,0x1e,0x00,0x13,0x13,0x13,0x00,0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,
+		0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,0x20,0x20,0x20,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x1b,0x1b,0x1b,0x00,0x0e,0x0e,0x0e,0x00,0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x0b,0x0b,0x0b,0x00,0x1c,0x1c,0x1c,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x20,0x20,0x20,0x00,0x16,0x16,0x16,0x00,0x0b,0x0b,0x0b,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x17,0x17,0x17,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x1c,0x1c,0x1c,0x00,0x13,0x13,0x13,0x00,0x08,0x08,0x08,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x11,0x11,0x11,0x00,0x21,0x21,0x21,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x20,0x20,0x20,0x00,0x19,0x19,0x19,0x00,0x0e,0x0e,0x0e,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x02,0x02,0x02,0x00,0x0b,0x0b,0x0b,0x00,0x1c,0x1c,0x1c,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x1e,0x1e,0x1e,0x00,0x15,0x15,0x15,0x00,0x09,0x09,0x09,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x08,0x08,0x08,0x00,0x18,0x18,0x18,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x1c,0x1c,0x1c,0x00,0x10,0x10,0x10,0x00,0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,
+		0x13,0x13,0x13,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x19,0x19,0x19,0x00,0x0d,0x0d,0x0d,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0d,0x0d,0x0d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x1e,0x1e,0x1e,0x00,
+		0x16,0x16,0x16,0x00,0x0a,0x0a,0x0a,0x00,0x03,0x03,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x0a,0x0a,0x0a,0x00,0x19,0x19,0x19,0x00,
+		0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x1c,0x1c,0x1c,0x00,
+		0x12,0x12,0x12,0x00,0x07,0x07,0x07,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x15,0x15,0x15,0x00,0x22,0x22,0x22,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x19,0x19,0x19,0x00,
+		0x0f,0x0f,0x0f,0x00,0x06,0x06,0x06,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x0f,0x0f,0x0f,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1d,0x1d,0x1d,0x00,0x16,0x16,0x16,0x00,
+		0x0c,0x0c,0x0c,0x00,0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x0b,0x0b,0x0b,0x00,0x19,0x19,0x19,0x00,0x24,0x24,0x24,0x00,0x26,0x26,0x26,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1c,0x1c,0x1c,0x00,0x13,0x13,0x13,0x00,
+		0x09,0x09,0x09,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x08,0x08,0x08,0x00,0x15,0x15,0x15,0x00,0x22,0x22,0x22,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,
+		0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1b,0x1b,0x1b,0x00,0x11,0x11,0x11,0x00,
+		0x08,0x08,0x08,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x04,0x04,0x04,0x00,0x10,0x10,0x10,0x00,0x1e,0x1e,0x1e,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x19,0x19,0x19,0x00,0x0f,0x0f,0x0f,0x00,
+		0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x0c,0x0c,0x0c,0x00,0x19,0x19,0x19,0x00,0x23,0x23,0x23,0x00,0x26,0x26,0x26,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x17,0x17,0x17,0x00,0x0d,0x0d,0x0d,0x00,
+		0x06,0x06,0x06,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,
+		0x15,0x15,0x15,0x00,0x21,0x21,0x21,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x26,0x26,0x26,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1b,0x1b,0x1b,0x00,0x16,0x16,0x16,0x00,0x0c,0x0c,0x0c,0x00,
+		0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x0f,0x0f,0x0f,0x00,
+		0x1d,0x1d,0x1d,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x19,0x19,0x19,0x00,0x13,0x13,0x13,0x00,0x0b,0x0b,0x0b,0x00,
+		0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x0b,0x0b,0x0b,0x00,0x18,0x18,0x18,0x00,
+		0x22,0x22,0x22,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x13,0x13,0x13,0x00,0x0b,0x0b,0x0b,0x00,
+		0x05,0x05,0x05,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x06,0x06,0x06,0x00,0x12,0x12,0x12,0x00,0x1f,0x1f,0x1f,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x17,0x17,0x17,0x00,0x12,0x12,0x12,0x00,0x0a,0x0a,0x0a,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0c,0x0c,0x0c,0x00,0x1b,0x1b,0x1b,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x10,0x10,0x10,0x00,0x0a,0x0a,0x0a,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x06,0x06,0x06,0x00,0x13,0x13,0x13,0x00,0x22,0x22,0x22,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x16,0x16,0x16,0x00,0x10,0x10,0x10,0x00,0x08,0x08,0x08,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0d,0x0d,0x0d,0x00,0x1c,0x1c,0x1c,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x0f,0x0f,0x0f,0x00,0x07,0x07,0x07,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x08,0x08,0x08,0x00,0x16,0x16,0x16,0x00,0x22,0x22,0x22,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x0e,0x0e,0x0e,0x00,0x07,0x07,0x07,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x10,0x10,0x10,0x00,0x1f,0x1f,0x1f,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x25,0x25,0x25,0x00,
+		0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x0e,0x0e,0x0e,0x00,0x07,0x07,0x07,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x0b,0x0b,0x0b,0x00,0x18,0x18,0x18,0x00,0x21,0x21,0x21,0x00,0x24,0x24,0x24,0x00,0x25,0x25,0x25,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x0e,0x0e,0x0e,0x00,0x08,0x08,0x08,0x00,
+		0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,
+		0x12,0x12,0x12,0x00,0x1e,0x1e,0x1e,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x08,0x08,0x08,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x0c,0x0c,0x0c,0x00,
+		0x1a,0x1a,0x1a,0x00,0x22,0x22,0x22,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x09,0x09,0x09,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x08,0x08,0x08,0x00,0x13,0x13,0x13,0x00,
+		0x1f,0x1f,0x1f,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,
+		0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x09,0x09,0x09,0x00,
+		0x04,0x04,0x04,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x00,0x0b,0x0b,0x0b,0x00,0x19,0x19,0x19,0x00,
+		0x22,0x22,0x22,0x00,0x24,0x24,0x24,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x09,0x09,0x09,0x00,
+		0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x11,0x11,0x11,0x00,0x1d,0x1d,0x1d,0x00,
+		0x23,0x23,0x23,0x00,0x24,0x24,0x24,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0a,0x0a,0x0a,0x00,
+		0x06,0x06,0x06,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,0x18,0x18,0x18,0x00,0x21,0x21,0x21,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x07,0x07,0x07,0x00,0x12,0x12,0x12,0x00,0x1d,0x1d,0x1d,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0a,0x0a,0x0a,0x00,0x16,0x16,0x16,0x00,0x20,0x20,0x20,0x00,0x23,0x23,0x23,0x00,
+		0x23,0x23,0x23,0x00,0x23,0x23,0x23,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x06,0x06,0x06,0x00,0x0f,0x0f,0x0f,0x00,0x1b,0x1b,0x1b,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x15,0x15,0x15,0x00,0x1f,0x1f,0x1f,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x05,0x05,0x05,0x00,0x0e,0x0e,0x0e,0x00,0x1b,0x1b,0x1b,0x00,0x21,0x21,0x21,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,
+		0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,
+		0x07,0x07,0x07,0x00,0x14,0x14,0x14,0x00,0x1f,0x1f,0x1f,0x00,0x22,0x22,0x22,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,
+		0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,
+		0x0b,0x0b,0x0b,0x00,0x16,0x16,0x16,0x00,0x1f,0x1f,0x1f,0x00,0x22,0x22,0x22,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,
+		0x0e,0x0e,0x0e,0x00,0x18,0x18,0x18,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,0x21,0x21,0x21,0x00,
+		0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,
+		0x12,0x12,0x12,0x00,0x1c,0x1c,0x1c,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,
+		0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,
+		0x17,0x17,0x17,0x00,0x1f,0x1f,0x1f,0x00,0x21,0x21,0x21,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0f,0x0f,0x0f,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1f,0x1f,0x1f,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x12,0x12,0x12,0x00,
+		0x1c,0x1c,0x1c,0x00,0x20,0x20,0x20,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,
+		0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x03,0x00,0x0a,0x0a,0x0a,0x00,0x14,0x14,0x14,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,0x17,0x17,0x17,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1f,0x1f,0x1f,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x10,0x10,0x10,0x00,0x19,0x19,0x19,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1e,0x1e,0x1e,0x00,0x1e,0x1e,0x1e,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x09,0x09,0x09,0x00,0x12,0x12,0x12,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x14,0x14,0x14,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x0b,0x0b,0x0b,0x00,0x15,0x15,0x15,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0c,0x0c,0x0c,0x00,0x15,0x15,0x15,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0d,0x0d,0x0d,0x00,0x16,0x16,0x16,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x07,0x07,0x07,0x00,0x0f,0x0f,0x0f,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x10,0x10,0x10,0x00,0x16,0x16,0x16,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x09,0x09,0x09,0x00,0x10,0x10,0x10,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,0x10,0x10,0x10,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x09,0x09,0x09,0x00,0x10,0x10,0x10,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x10,0x10,0x10,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x08,0x08,0x08,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x08,0x08,0x08,0x00,0x0f,0x0f,0x0f,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0d,0x0d,0x0d,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x05,0x05,0x05,0x00,0x0a,0x0a,0x0a,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x04,0x04,0x00,0x08,0x08,0x08,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x06,0x06,0x06,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x05,0x05,0x05,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0a,0x0a,0x0a,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x07,0x07,0x07,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x19,0x19,0x19,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x04,0x04,0x04,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x09,0x09,0x09,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,0x15,0x15,0x15,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1c,0x1c,0x1c,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,
+		0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x11,0x11,0x11,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x1a,0x1a,0x1a,0x00,0x1c,0x1c,0x1c,0x00,0x1d,0x1d,0x1d,0x00,0x1c,0x1c,0x1c,0x00,
+		0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0a,0x0a,0x0a,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1b,0x1b,0x1b,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,0x1a,0x1a,0x1a,0x00,
+		0x1a,0x1a,0x1a,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,
+		0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x19,0x19,0x19,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,
+		0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,
+		0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,
+		0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,
+		0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x17,0x17,0x17,0x00,0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,
+		0x16,0x16,0x16,0x00,0x16,0x16,0x16,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x15,0x15,0x15,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,
+		0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x14,0x14,0x14,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,
+		0x13,0x13,0x13,0x00,0x13,0x13,0x13,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,0x12,0x12,0x12,0x00,
+		0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x11,0x11,0x11,0x00,0x10,0x10,0x10,0x00,0x10,0x10,0x10,0x00,
+		0x10,0x10,0x10,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,
+		0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0f,0x0f,0x0f,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,
+		0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0e,0x0e,0x0e,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,0x0d,0x0d,0x0d,0x00,
+		0x0d,0x0d,0x0d,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0c,0x0c,0x0c,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,0x0b,0x0b,0x0b,0x00,
+		0x0b,0x0b,0x0b,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,0x0a,0x0a,0x0a,0x00,
+		0x0a,0x0a,0x0a,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x09,0x09,0x09,0x00,0x08,0x08,0x08,0x00,
+		0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x08,0x08,0x08,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,
+		0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x07,0x07,0x07,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,
+		0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x06,0x06,0x06,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,0x05,0x05,0x05,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,
+		0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x04,0x04,0x04,0x00,0x03,0x03,0x03,0x00,
+		0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x03,0x03,0x03,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,
+		0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x02,0x02,0x02,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,
+		0x01,0x01,0x01,0x00,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
+};
diff --git a/client/x11/main.cpp b/client/x11/main.cpp
new file mode 100644
index 00000000..de920f9b
--- /dev/null
+++ b/client/x11/main.cpp
@@ -0,0 +1,50 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "application.h"
+#include "config.h"
+
+static void cleanup()
+{
+    log4cpp::Category::shutdown();
+}
+
+const char * version_str = VERSION;
+
+int main(int argc, char** argv)
+{
+    int exit_val;
+
+    atexit(cleanup);
+    try {
+        exit_val = Application::main(argc, argv, version_str);
+        LOG_INFO("Spice client terminated (exitcode = %d)", exit_val);
+    } catch (Exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+        exit_val = e.get_error_code();
+    } catch (std::exception& e) {
+        LOG_ERROR("unhandle exception: %s", e.what());
+        exit_val = SPICEC_ERROR_CODE_ERROR;
+    } catch (...) {
+        LOG_ERROR("unhandled exception");
+        exit_val = SPICEC_ERROR_CODE_ERROR;
+    }
+
+    return exit_val;
+}
+
diff --git a/client/x11/named_pipe.cpp b/client/x11/named_pipe.cpp
new file mode 100644
index 00000000..73d103c0
--- /dev/null
+++ b/client/x11/named_pipe.cpp
@@ -0,0 +1,169 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/epoll.h>
+#include <sys/un.h>
+#include "named_pipe.h"
+#include "utils.h"
+#include "debug.h"
+
+Session::Session(int fd, EventsLoop& events_loop)
+    : _fd_client(fd)
+    , _events_loop(events_loop)
+{
+}
+
+void Session::on_event()
+{
+    _conn_interface->on_data();
+}
+
+void Session::bind(NamedPipe::ConnectionInterface* conn_interface)
+{
+    _conn_interface = conn_interface;
+    _events_loop.add_socket(*this);
+}
+
+Session::~Session()
+{
+    _events_loop.remove_socket(*this);
+    close(_fd_client);
+}
+
+int32_t Session::write(const uint8_t *buf, int32_t size)
+{
+    const uint8_t *pos = buf;
+
+    while (size) {
+        int now;
+        if ((now = send(_fd_client, (char *)pos, size, 0)) == -1) {
+            if (errno == EAGAIN) {
+                break;
+            }
+            if (errno == EINTR) {
+                continue;
+            }
+            DBG(0, "send error errno=%d, %s", errno, strerror(errno));
+            return -1;
+        }
+        size -= now;
+        pos += now;
+    }
+    return (pos - buf);
+}
+
+int32_t Session::read(uint8_t *buf, int32_t size)
+{
+    uint8_t *pos = buf;
+    while (size) {
+        int now;
+        if ((now = recv(_fd_client, (char *)pos, size, 0)) <= 0) {
+            if (now == 0) {
+                DBG(0, "read error, connetion shutdown");
+                return -1;
+            }
+            if (errno == EAGAIN) {
+                break;
+            }
+            if (errno == EINTR) {
+                continue;
+            }
+            DBG(0, "read error errno=%d, %s", errno, strerror(errno));
+            return -1;
+        }
+        size -= now;
+        pos += now;
+    }
+    return (pos - buf);
+}
+
+int LinuxListener::create_socket(const char *socket_name)
+{
+    int listen_socket;
+    struct sockaddr_un local;
+
+    if ((listen_socket = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+        DBG(0, "create socket error, errno=%d, %s", errno, strerror(errno));
+        return -1;
+    }
+
+    _name = socket_name;
+
+    local.sun_family = AF_UNIX;
+    strcpy(local.sun_path, socket_name);
+    unlink(local.sun_path);
+    if (bind(listen_socket, (struct sockaddr *)&local,
+             strlen(local.sun_path) + sizeof(local.sun_family)) == -1) {
+        DBG(0, "bind error, errno=%d, %s", errno, strerror(errno));
+        return -1;
+    }
+    if (listen(listen_socket, 10) == -1) {
+        DBG(0, "listen error, errno=%d, %s", errno, strerror(errno));
+        return -1;
+    }
+    return listen_socket;
+}
+
+LinuxListener::LinuxListener(const char *name, NamedPipe::ListenerInterface &listener_interface,
+                             EventsLoop &events_loop)
+    : _listener_interface (listener_interface)
+    , _events_loop (events_loop)
+{
+    _listen_socket = create_socket(name);
+    if (_listen_socket <= 0) {
+        THROW("Listener creation failed %d", _listen_socket);
+    }
+    _events_loop.add_socket(*this);
+
+    DBG(0, "listening socket - %s, added to events_loop", name);
+}
+
+LinuxListener::~LinuxListener()
+{
+    _events_loop.remove_socket(*this);
+    close(_listen_socket);
+    unlink(_name.c_str());
+}
+
+void LinuxListener::on_event()
+{
+    for (;;) {
+        int fd_client;
+        Session *conn;
+        struct sockaddr_un remote;
+        socklen_t len = sizeof(remote);
+
+        if ((fd_client = accept(_listen_socket, (struct sockaddr *)&remote, &len)) == -1) {
+            if (errno == EAGAIN) {
+                break;
+            }
+            if (errno == EINTR) {
+                continue;
+            }
+            THROW("errno=%d, %s", errno, strerror(errno));
+        }
+
+        conn = new Session(fd_client, _events_loop);
+        DBG(0, "New connection created, fd: %d", fd_client);
+        NamedPipe::ConnectionInterface &conn_interface = _listener_interface.create();
+        conn->bind(&conn_interface);
+        conn_interface.bind((NamedPipe::ConnectionRef)conn);
+    }
+}
+
diff --git a/client/x11/named_pipe.h b/client/x11/named_pipe.h
new file mode 100644
index 00000000..ab41f7f3
--- /dev/null
+++ b/client/x11/named_pipe.h
@@ -0,0 +1,62 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_NAMED_PIPE
+#define _H_NAMED_PIPE
+
+#include "platform.h"
+#include "x_platform.h"
+#include "events_loop.h"
+
+class Session: public EventsLoop::Socket {
+public:
+    Session(int fd, EventsLoop& events_loop);
+    virtual ~Session();
+    void bind(NamedPipe::ConnectionInterface* conn_interface);
+
+public:
+    virtual void on_event();
+    virtual int get_socket() {return _fd_client;}
+    int32_t write(const uint8_t *buf, int32_t size);
+    int32_t read(uint8_t *buf, int32_t size);
+
+private:
+    NamedPipe::ConnectionInterface *_conn_interface;
+    int _fd_client;
+    EventsLoop &_events_loop;
+};
+
+class LinuxListener: public EventsLoop::Socket {
+public:
+    LinuxListener(const char *name, NamedPipe::ListenerInterface &listener_interface,
+                  EventsLoop &events_loop);
+    virtual ~LinuxListener();
+    void on_event();
+    virtual int get_socket() {return _listen_socket;}
+
+private:
+    int create_socket(const char *socket_name);
+
+private:
+    NamedPipe::ListenerInterface &_listener_interface;
+    int _listen_socket;
+    std::string _name;
+    EventsLoop &_events_loop;
+};
+
+#endif
+
diff --git a/client/x11/pixels_source.cpp b/client/x11/pixels_source.cpp
new file mode 100644
index 00000000..d8d8cb75
--- /dev/null
+++ b/client/x11/pixels_source.cpp
@@ -0,0 +1,129 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "x_platform.h"
+#include "pixels_source.h"
+#include "pixels_source_p.h"
+#include "utils.h"
+#include "debug.h"
+#include "res.h"
+
+
+static void create_image(const PixmapHeader* pixmap, PixelsSource_p& pixels_source,
+                         cairo_format_t cairo_format)
+{
+    cairo_surface_t* cairo_surf;
+    XImage *image = new XImage;
+
+    memset(image, 0, sizeof(*image));
+    image->width = pixmap->width;
+    image->height = pixmap->height;
+
+    image->data = (char*)pixmap->data;
+    image->byte_order = LSBFirst;
+    image->bitmap_unit = 32;
+    image->bitmap_bit_order = LSBFirst;
+    image->bitmap_pad = 32;
+    image->bytes_per_line = pixmap->stride;
+
+    image->depth = XPlatform::get_vinfo()[0]->depth;
+    image->format = ZPixmap;
+    image->bits_per_pixel = 32;
+    image->red_mask = 0x00ff0000;
+    image->green_mask = 0x0000ff00;
+    image->blue_mask = 0x000000ff;
+
+    try {
+        if (!XInitImage(image)) {
+            THROW("init image failed");
+        }
+
+        cairo_surf = cairo_image_surface_create_for_data(pixmap->data, cairo_format,
+                                                         pixmap->width, pixmap->height,
+                                                         pixmap->stride);
+        if (cairo_surface_status(cairo_surf) != CAIRO_STATUS_SUCCESS) {
+            THROW("surf create failed");
+        }
+    } catch (...) {
+        delete image;
+        throw;
+    }
+
+    pixels_source.type = PIXELS_SOURCE_TYPE_PIXMAP;
+    pixels_source.pixmap.x_image = image;
+    pixels_source.pixmap.cairo_surf = cairo_surf;
+}
+
+PixelsSource::PixelsSource()
+{
+    _origin.x = _origin.y = 0;
+    memset(_opaque, 0, sizeof(_opaque));
+}
+
+PixelsSource::~PixelsSource()
+{
+}
+
+ImageFromRes::ImageFromRes(int res_id)
+{
+    const PixmapHeader* pixmap = res_get_image(res_id);
+    if (!pixmap) {
+        THROW("no image %d", res_id);
+    }
+    create_image(pixmap, *(PixelsSource_p*)get_opaque(), CAIRO_FORMAT_RGB24);
+}
+
+ImageFromRes::~ImageFromRes()
+{
+    cairo_surface_destroy(((PixelsSource_p*)get_opaque())->pixmap.cairo_surf);
+    delete ((PixelsSource_p*)get_opaque())->pixmap.x_image;
+}
+
+Point ImageFromRes::get_size()
+{
+    XImage *image = ((PixelsSource_p*)get_opaque())->pixmap.x_image;
+    Point pt;
+    pt.x = image->width;
+    pt.y = image->height;
+    return pt;
+}
+
+AlphaImageFromRes::AlphaImageFromRes(int res_id)
+{
+    const PixmapHeader* pixmap = res_get_image(res_id);
+    if (!pixmap) {
+        THROW("no image %d", res_id);
+    }
+    create_image(pixmap, *(PixelsSource_p*)get_opaque(), CAIRO_FORMAT_ARGB32);
+}
+
+AlphaImageFromRes::~AlphaImageFromRes()
+{
+    cairo_surface_destroy(((PixelsSource_p*)get_opaque())->pixmap.cairo_surf);
+    delete ((PixelsSource_p*)get_opaque())->pixmap.x_image;
+}
+
+Point AlphaImageFromRes::get_size()
+{
+    XImage *image = ((PixelsSource_p*)get_opaque())->pixmap.x_image;
+    Point pt;
+    pt.x = image->width;
+    pt.y = image->height;
+    return pt;
+}
+
diff --git a/client/x11/pixels_source_p.h b/client/x11/pixels_source_p.h
new file mode 100644
index 00000000..69d6998b
--- /dev/null
+++ b/client/x11/pixels_source_p.h
@@ -0,0 +1,88 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PIXELE_SOURSR_P
+#define _H_PIXELE_SOURSR_P
+
+#define GL_GLEXT_PROTOTYPES
+#include <X11/X.h>
+#include <GL/glu.h>
+#include <X11/extensions/XShm.h>
+#include "red_window.h"
+#include "red_pixmap_gl.h"
+#include "cairo.h"
+
+enum {
+    PIXELS_SOURCE_TYPE_INVALID,
+    PIXELS_SOURCE_TYPE_X_DRAWABLE,
+    PIXELS_SOURCE_TYPE_XSHM_DRAWABLE,
+    PIXELS_SOURCE_TYPE_PIXMAP,
+    PIXELS_SOURCE_TYPE_GL_TEXTURE,
+    PIXELS_SOURCE_TYPE_GL_DRAWABLE,
+};
+
+struct PixelsSource_p {
+    int type;
+    union {
+        struct {
+            Drawable drawable;
+            GC gc;
+            int width, height;
+            RenderType rendertype;
+            union {
+                GLXPbuffer pbuff;
+                GLuint fbo;
+            };
+            RedGlContext context;
+        } x_drawable;
+
+        struct {
+            XImage* x_image;
+            XShmSegmentInfo *shminfo;
+            cairo_surface_t* cairo_surf;
+        } x_shm_drawable;
+
+        struct {
+            XImage* x_image;
+            cairo_surface_t* cairo_surf;
+        } pixmap;
+
+        struct {
+            RenderType rendertype;
+            Win win;
+            GLuint tex;
+            GLuint stencil_tex;
+            int width, height;
+            int width_powed, height_powed;
+            union {
+                GLXPbuffer pbuff;
+                GLuint fbo;
+            };
+            RedGlContext context;
+        } gl;
+    };
+};
+
+struct RedDrawable_p {
+    PixelsSource_p source;
+    union {
+        cairo_t* cairo;
+    };
+};
+
+#endif
+
diff --git a/client/x11/platform.cpp b/client/x11/platform.cpp
new file mode 100644
index 00000000..c99595a3
--- /dev/null
+++ b/client/x11/platform.cpp
@@ -0,0 +1,2643 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/XKBlib.h>
+#include <X11/Xresource.h>
+#include <X11/cursorfont.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/render.h>
+#include <X11/extensions/XKB.h>
+#include <X11/extensions/Xrender.h>
+#include <unistd.h>
+#include <sys/epoll.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <set>
+#include <values.h>
+#include <signal.h>
+#include <config.h>
+
+#include "platform.h"
+#include "application.h"
+#include "utils.h"
+#include "x_platform.h"
+#include "debug.h"
+#include "monitor.h"
+#include "rect.h"
+#include "record.h"
+#include "playback.h"
+#include "resource.h"
+#include "res.h"
+#include "cursor.h"
+#include "events_loop.h"
+
+#define DWORD uint32_t
+#define BOOL bool
+#include "named_pipe.h"
+
+//#define X_DEBUG_SYNC(display) XSync(display, False)
+#define X_DEBUG_SYNC(display)
+#ifdef HAVE_XRANDR12
+#define USE_XRANDR_1_2
+#endif
+
+static Display* x_display = NULL;
+static XVisualInfo **vinfo = NULL;
+static GLXFBConfig **fb_config;
+
+static EventsLoop events_loop;
+static XContext win_proc_context;
+static bool quit_request = false;
+static pthread_t main_thread;
+static int focus_count = 0;
+
+static bool using_xrandr_1_0 = false;
+#ifdef USE_XRANDR_1_2
+static bool using_xrandr_1_2 = false;
+#endif
+
+static int xrandr_event_base;
+static int xrandr_error_base;
+static int xrandr_major = 0;
+static int xrandr_minor = 0;
+
+static bool using_xrender_0_5 = false;
+
+static unsigned int caps_lock_mask = 0;
+static unsigned int num_lock_mask = 0;
+
+class DefaultEventListener: public Platform::EventListener {
+public:
+    virtual void on_app_activated() {}
+    virtual void on_app_deactivated() {}
+    virtual void on_monitors_change() {}
+};
+
+static DefaultEventListener default_event_listener;
+static Platform::EventListener* event_listener = &default_event_listener;
+
+class DefaultDisplayModeListner: public Platform::DisplayModeListner {
+public:
+    void on_display_mode_change() {}
+};
+
+static DefaultDisplayModeListner default_display_mode_listener;
+static Platform::DisplayModeListner* display_mode_listener = &default_display_mode_listener;
+
+
+NamedPipe::ListenerRef NamedPipe::create(const char *name, ListenerInterface& listener_interface)
+{
+    return (ListenerRef)(new LinuxListener(name, listener_interface, events_loop));
+}
+
+void NamedPipe::destroy(ListenerRef listener_ref)
+{
+    delete (LinuxListener *)listener_ref;
+}
+
+void NamedPipe::destroy_connection(ConnectionRef conn_ref)
+{
+    delete (Session *)conn_ref;
+}
+
+int32_t NamedPipe::read(ConnectionRef conn_ref, uint8_t* buf, int32_t size)
+{
+    if (((Session *)conn_ref) != NULL) {
+        return ((Session *)conn_ref)->read(buf, size);
+    }
+    return -1;
+}
+
+int32_t NamedPipe::write(ConnectionRef conn_ref, const uint8_t* buf, int32_t size)
+{
+    if (((Session *)conn_ref) != NULL) {
+        return ((Session *)conn_ref)->write(buf, size);
+    }
+    return -1;
+}
+
+class XEventHandler: public EventsLoop::File {
+public:
+    XEventHandler(Display& x_display);
+    virtual void on_event() {}
+    virtual int get_fd() {return _x_fd;}
+
+private:
+    int _x_fd;
+};
+
+XEventHandler::XEventHandler(Display& x_display)
+{
+    if ((_x_fd = ConnectionNumber(&x_display)) == -1) {
+        THROW("get x fd failed");
+    }
+}
+
+class WakeupEventHandler: public EventsLoop::Trigger {
+public:
+    virtual void on_event() {}
+};
+
+static WakeupEventHandler wakeup_handler;
+
+#define NSEC_PER_SEC (1000 * 1000 * 1000)
+
+class Timer {
+public:
+    Timer(timer_proc_t proc, void* opaque);
+    ~Timer();
+
+    void arm(uint32_t msec);
+    void disarm();
+    bool action(const timespec& now);
+
+    const timespec& get_experatoin() const { return _experatoin;}
+
+    static int get_timout();
+    static void timers_action();
+
+private:
+    void calc_next_experatoin_time();
+
+    static bool timespec_less(const timespec& time, const timespec& from);
+    static bool timespec_equal(const timespec& time, const timespec& from);
+    static bool timespec_less_or_equal(const timespec& time, const timespec& from);
+
+public:
+    static RecurciveMutex timers_lock;
+
+private:
+    timer_proc_t _proc;
+    void* _opaque;
+    bool _armed;
+    timespec _interval;
+    timespec _experatoin;
+
+    class Compare {
+    public:
+        bool operator () (const Timer* timer1, const Timer* timer2) const
+        {
+            if (!Timer::timespec_less(timer1->get_experatoin(), timer2->get_experatoin())) {
+                return Timer::timespec_equal(timer1->get_experatoin(), timer2->get_experatoin()) ?
+                                                                            timer1 < timer2 : false;
+            }
+            return true;
+        }
+    };
+
+    typedef std::set<Timer*, Compare> TimersSet;
+    static TimersSet armed_timers;
+};
+
+Timer::TimersSet Timer::armed_timers;
+RecurciveMutex Timer::timers_lock;
+
+Display* XPlatform::get_display()
+{
+    return x_display;
+}
+
+XVisualInfo** XPlatform::get_vinfo()
+{
+    return vinfo;
+}
+
+GLXFBConfig** XPlatform::get_fbconfig()
+{
+    return fb_config;
+}
+
+void XPlatform::set_win_proc(Window win, win_proc_t proc)
+{
+    if (XSaveContext(x_display, win, win_proc_context, (XPointer)proc)) {
+        THROW("set win proc pailed");
+    }
+}
+
+void XPlatform::cleare_win_proc(Window win)
+{
+    XDeleteContext(x_display, win, win_proc_context);
+}
+
+void Platform::send_quit_request()
+{
+    quit_request = true;
+    wakeup();
+}
+
+void Platform::wait_events()
+{
+    ASSERT(pthread_self() == main_thread);
+    XFlush(x_display);
+    if (!XPending(x_display)) {
+        events_loop.run_once(Timer::get_timout());
+        Timer::timers_action();
+    }
+}
+
+void Platform::wakeup()
+{
+    wakeup_handler.trigger();
+}
+
+bool Platform::process_events()
+{
+    ASSERT(pthread_self() == main_thread);
+    while (XPending(x_display)) {
+        XPointer proc_pointer;
+        XEvent event;
+
+        XNextEvent(x_display, &event);
+        if (event.xany.window == None) {
+            LOG_WARN("invalid window");
+            continue;
+        }
+
+        if (XFindContext(x_display, event.xany.window, win_proc_context, &proc_pointer)) {
+            THROW("no window proc");
+        }
+        ((XPlatform::win_proc_t)proc_pointer)(event);
+    }
+    return quit_request;
+}
+
+uint64_t Platform::get_monolithic_time()
+{
+    struct timespec time_space;
+    clock_gettime(CLOCK_MONOTONIC, &time_space);
+    return uint64_t(time_space.tv_sec) * 1000 * 1000 * 1000 + uint64_t(time_space.tv_nsec);
+}
+
+void Platform::get_temp_dir(std::string& path)
+{
+    path = "/tmp/";
+}
+
+void Platform::msleep(unsigned int millisec)
+{
+    usleep(millisec * 1000);
+}
+
+void Platform::yield()
+{
+    pthread_yield();
+}
+
+void Platform::set_thread_priority(void* thread, Platform::ThreadPriority in_priority)
+{
+    ASSERT(thread == NULL);
+    int priority;
+
+    switch (in_priority) {
+    case PRIORITY_TIME_CRITICAL:
+        priority = -20;
+        break;
+    case PRIORITY_HIGH:
+        priority = -2;
+        break;
+    case PRIORITY_ABOVE_NORMAL:
+        priority = -1;
+        break;
+    case PRIORITY_NORMAL:
+        priority = 0;
+        break;
+    case PRIORITY_BELOW_NORMAL:
+        priority = 1;
+        break;
+    case PRIORITY_LOW:
+        priority = 2;
+        break;
+    case PRIORITY_IDLE:
+        priority = 19;
+        break;
+    default:
+        THROW("invalid priority %d", in_priority);
+    }
+
+    pid_t tid = syscall(SYS_gettid);
+    if (setpriority(PRIO_PROCESS, tid, priority) == -1) {
+        DBG(0, "setpriority failed %s", strerror(errno));
+    }
+}
+
+Timer::Timer(timer_proc_t proc, void* opaque)
+    : _proc (proc)
+    , _opaque (opaque)
+    , _armed (false)
+{
+}
+
+Timer::~Timer()
+{
+    disarm();
+}
+
+void Timer::arm(uint32_t msec)
+{
+    disarm();
+    _interval.tv_sec = msec / 1000;
+    _interval.tv_nsec = (msec % 1000) * 1000 * 1000;
+    if (clock_gettime(CLOCK_MONOTONIC, &_experatoin)) {
+        THROW("gettime failed %s", strerror(errno));
+    }
+    calc_next_experatoin_time();
+    _armed = true;
+    armed_timers.insert(this);
+}
+
+void Timer::disarm()
+{
+    if (!_armed) {
+        return;
+    }
+    armed_timers.erase(this);
+    _armed = false;
+}
+
+#define TINER_COMPENSATION
+
+bool Timer::action(const timespec& now)
+{
+    ASSERT(_armed);
+    ASSERT(now.tv_nsec < NSEC_PER_SEC);
+
+    if (timespec_less(now, _experatoin)) {
+        return false;
+    }
+    armed_timers.erase(this);
+#ifndef TINER_COMPENSATION
+    _experatoin = now;
+#endif
+    calc_next_experatoin_time();
+#ifdef TINER_COMPENSATION
+    if (timespec_less_or_equal(_experatoin, now)) {
+        _experatoin = now;
+        calc_next_experatoin_time();
+    }
+#endif
+    armed_timers.insert(this);
+    _proc(_opaque, (TimerID)this);
+    return true;
+}
+
+int Timer::get_timout()
+{
+    RecurciveLock lock(Timer::timers_lock);
+    TimersSet::iterator iter;
+    iter = armed_timers.begin();
+    if (iter == armed_timers.end()) {
+        return -1;
+    }
+
+    timespec now;
+    if (clock_gettime(CLOCK_MONOTONIC, &now)) {
+        THROW("gettime failed %s", strerror(errno));
+    }
+
+    const timespec& next_time = (*iter)->get_experatoin();
+
+    if (!timespec_less(now, next_time)) {
+        return 0;
+    }
+    return ((next_time.tv_nsec - now.tv_nsec) / 1000 / 1000) +
+           (next_time.tv_sec - now.tv_sec) * 1000;
+}
+
+void Timer::timers_action()
+{
+    RecurciveLock lock(timers_lock);
+    timespec now;
+    if (clock_gettime(CLOCK_MONOTONIC, &now)) {
+        THROW("gettime failed %s", strerror(errno));
+    }
+
+    TimersSet::iterator iter;
+    while ((iter = armed_timers.begin()) != armed_timers.end() && (*iter)->action(now));
+}
+
+void Timer::calc_next_experatoin_time()
+{
+    _experatoin.tv_nsec += _interval.tv_nsec;
+    _experatoin.tv_sec += (_experatoin.tv_nsec / NSEC_PER_SEC) + _interval.tv_sec;
+    _experatoin.tv_nsec %= NSEC_PER_SEC;
+}
+
+bool Timer::timespec_less(const timespec& time, const timespec& from)
+{
+    return time.tv_sec < from.tv_sec || (time.tv_sec == from.tv_sec && time.tv_nsec < from.tv_nsec);
+}
+
+bool Timer::timespec_equal(const timespec& time, const timespec& from)
+{
+    return time.tv_sec == from.tv_sec && time.tv_nsec <= from.tv_nsec;
+}
+
+bool Timer::timespec_less_or_equal(const timespec& time, const timespec& from)
+{
+    return time.tv_sec < from.tv_sec ||
+           (time.tv_sec == from.tv_sec && time.tv_nsec <= from.tv_nsec);
+}
+
+TimerID Platform::create_interval_timer(timer_proc_t proc, void* opaque)
+{
+    return (TimerID) new Timer(proc, opaque);
+}
+
+bool Platform::activate_interval_timer(TimerID timer, unsigned int millisec)
+{
+    RecurciveLock lock(Timer::timers_lock);
+    ((Timer*)timer)->arm(millisec);
+    if (pthread_self() != main_thread) {
+        wakeup();
+    }
+    return true;
+}
+
+bool Platform::deactivate_interval_timer(TimerID timer)
+{
+    RecurciveLock lock(Timer::timers_lock);
+    ((Timer*)timer)->disarm();
+    return true;
+}
+
+void Platform::destroy_interval_timer(TimerID timer)
+{
+    if (timer == INVALID_TIMER) {
+        return;
+    }
+    RecurciveLock lock(Timer::timers_lock);
+    delete (Timer*)timer;
+}
+
+void Platform::set_event_listener(EventListener* listener)
+{
+    event_listener = listener ? listener : &default_event_listener;
+}
+
+void Platform::set_display_mode_listner(DisplayModeListner* listener)
+{
+    display_mode_listener = listener ? listener : &default_display_mode_listener;
+}
+
+#ifdef USE_XRANDR_1_2
+class FreeScreenResources {
+public:
+    void operator () (XRRScreenResources* res) { XRRFreeScreenResources(res);}
+};
+typedef _AutoRes<XRRScreenResources, FreeScreenResources> AutoScreenRes;
+
+class FreeOutputInfo {
+public:
+    void operator () (XRROutputInfo* output_info) { XRRFreeOutputInfo(output_info);}
+};
+
+typedef _AutoRes<XRROutputInfo, FreeOutputInfo> AutoOutputInfo;
+
+class FreeCrtcInfo {
+public:
+    void operator () (XRRCrtcInfo* crtc_info) { XRRFreeCrtcInfo(crtc_info);}
+};
+typedef _AutoRes<XRRCrtcInfo, FreeCrtcInfo> AutoCrtcInfo;
+
+static XRRModeInfo* find_mod(XRRScreenResources* res, RRMode mode)
+{
+    for (int i = 0; i < res->nmode; i++) {
+        if (res->modes[i].id == mode) {
+            return &res->modes[i];
+        }
+    }
+    return NULL;
+}
+
+#endif
+
+//#define SHOW_SCREEN_INFO
+#ifdef SHOW_SCREEN_INFO
+
+static float mode_refresh(XRRModeInfo *mode_info)
+{
+    if (!mode_info->hTotal || !mode_info->vTotal) {
+        return 0;
+    }
+
+    return ((float)mode_info->dotClock / ((float)mode_info->hTotal * (float)mode_info->vTotal));
+}
+
+static void show_scren_info()
+{
+    int screen = DefaultScreen(x_display);
+    Window root_window = RootWindow(x_display, screen);
+
+    int minWidth;
+    int minHeight;
+    int maxWidth;
+    int maxHeight;
+
+    AutoScreenRes res(XRRGetScreenResources(x_display, root_window));
+
+    if (!res.valid()) {
+        throw Exception(fmt("%s: get screen resources failed") % __FUNCTION__);
+    }
+
+    XRRGetScreenSizeRange(x_display, root_window, &minWidth, &minHeight,
+                          &maxWidth, &maxHeight);
+    printf("screen: min %dx%d max %dx%d\n", minWidth, minHeight,
+           maxWidth, maxHeight);
+
+    int i, j;
+
+    for (i = 0; i < res->noutput; i++) {
+        AutoOutputInfo output_info(XRRGetOutputInfo(x_display, res.get(), res->outputs[i]));
+
+        printf("output %s", output_info->name);
+        if (output_info->crtc == None) {
+            printf(" crtc None");
+        } else {
+            printf(" crtc 0x%lx", output_info->crtc);
+        }
+        switch (output_info->connection) {
+        case RR_Connected:
+            printf(" Connected");
+            break;
+        case RR_Disconnected:
+            printf(" Disconnected");
+            break;
+        case RR_UnknownConnection:
+            printf(" UnknownConnection");
+            break;
+        }
+        printf(" ncrtc %u nclone %u nmode %u\n",
+               output_info->ncrtc,
+               output_info->nclone,
+               output_info->nmode);
+        for (j = 0; j < output_info->nmode; j++) {
+            XRRModeInfo* mode = find_mod(res.get(), output_info->modes[j]);
+            printf("\t%lu:", output_info->modes[j]);
+            if (!mode) {
+                printf(" ???\n");
+                continue;
+            }
+            printf(" %s %ux%u %f\n", mode->name, mode->width, mode->height, mode_refresh(mode));
+        }
+    }
+
+    for (i = 0; i < res->ncrtc; i++) {
+        AutoCrtcInfo crtc_info(XRRGetCrtcInfo(x_display, res.get(), res->crtcs[i]));
+        printf("crtc: 0x%lx x %d y %d  width %u height %u  mode %lu\n",
+               res->crtcs[i],
+               crtc_info->x, crtc_info->y,
+               crtc_info->width, crtc_info->height, crtc_info->mode);
+    }
+}
+
+#endif
+
+enum RedScreenRotation {
+    RED_SCREEN_ROTATION_0,
+    RED_SCREEN_ROTATION_90,
+    RED_SCREEN_ROTATION_180,
+    RED_SCREEN_ROTATION_270,
+};
+
+enum RedSubpixelOrder {
+    RED_SUBPIXEL_ORDER_UNKNOWN,
+    RED_SUBPIXEL_ORDER_H_RGB,
+    RED_SUBPIXEL_ORDER_H_BGR,
+    RED_SUBPIXEL_ORDER_V_RGB,
+    RED_SUBPIXEL_ORDER_V_BGR,
+    RED_SUBPIXEL_ORDER_NONE,
+};
+
+static void root_win_proc(XEvent& event);
+static void process_monitor_configure_events(Window root);
+
+class XMonitor;
+typedef std::list<XMonitor*> XMonitorsList;
+
+class XScreen {
+public:
+    XScreen(Display* display, int screen);
+    virtual ~XScreen() {}
+
+    virtual void publish_monitors(MonitorsList& monitors) = 0;
+
+    Display* get_display() {return _display;}
+    int get_screen() {return _screen;}
+
+    void set_broken() {_broken = true;}
+    bool is_broken() const {return _broken;}
+    int get_width() const {return _width;}
+    void set_width(int width) {_width = width;}
+    int get_height() const { return _height;}
+    void set_height(int height) {_height = height;}
+    Point get_position() const {return _position;}
+
+private:
+    Display* _display;
+    int _screen;
+    Point _position;
+    int _width;
+    int _height;
+    bool _broken;
+};
+
+XScreen::XScreen(Display* display, int screen)
+    : _display (display)
+    , _screen (screen)
+    , _broken (false)
+{
+    int root = RootWindow(display, screen);
+
+    XWindowAttributes attrib;
+    XGetWindowAttributes(display, root, &attrib);
+
+    _position.x = attrib.x;
+    _position.y = attrib.y;
+    _width = attrib.width;
+    _height = attrib.height;
+}
+
+class StaticScreen: public XScreen, public Monitor {
+public:
+    StaticScreen(Display* display, int screen, int& next_mon_id)
+        : XScreen(display, screen)
+        , Monitor(next_mon_id++)
+        , _out_of_sync (false)
+    {
+    }
+
+    virtual void publish_monitors(MonitorsList& monitors)
+    {
+        monitors.push_back(this);
+    }
+
+    virtual void set_mode(int width, int height)
+    {
+        _out_of_sync = width > get_width() || height > get_height();
+    }
+
+    virtual void restore() {}
+    virtual int get_depth() { return XPlatform::get_vinfo()[0]->depth;}
+    virtual Point get_position() { return XScreen::get_position();}
+    virtual Point get_size() const { Point pt = {get_width(), get_height()}; return pt;}
+    virtual bool is_out_of_sync() { return _out_of_sync;}
+    virtual int get_screen_id() { return get_screen();}
+
+private:
+    bool _out_of_sync;
+};
+
+class DynamicScreen: public XScreen, public Monitor {
+public:
+    DynamicScreen(Display* display, int screen, int& next_mon_id);
+    virtual ~DynamicScreen();
+
+    void publish_monitors(MonitorsList& monitors);
+    virtual void set_mode(int width, int height);
+    virtual void restore();
+    virtual int get_depth() { return XPlatform::get_vinfo()[0]->depth;}
+    virtual Point get_position() { return XScreen::get_position();}
+    virtual Point get_size() const { Point pt = {get_width(), get_height()}; return pt;}
+    virtual bool is_out_of_sync() { return _out_of_sync;}
+    virtual int get_screen_id() { return get_screen();}
+
+private:
+    bool set_screen_size(int size_index);
+
+private:
+    int _saved_width;
+    int _saved_height;
+    bool _out_of_sync;
+};
+
+DynamicScreen::DynamicScreen(Display* display, int screen, int& next_mon_id)
+    : XScreen(display, screen)
+    , Monitor(next_mon_id++)
+    , _saved_width (get_width())
+    , _saved_height (get_height())
+    , _out_of_sync (false)
+{
+    X_DEBUG_SYNC(display);
+    Window root_window = RootWindow(display, screen);
+    XSelectInput(display, root_window, StructureNotifyMask);
+    XRRSelectInput(display, root_window, RRScreenChangeNotifyMask);
+    XPlatform::set_win_proc(root_window, root_win_proc);
+    X_DEBUG_SYNC(display);
+}
+
+DynamicScreen::~DynamicScreen()
+{
+    restore();
+}
+
+void DynamicScreen::publish_monitors(MonitorsList& monitors)
+{
+    monitors.push_back(this);
+}
+
+class SizeInfo {
+public:
+    SizeInfo(int int_index, XRRScreenSize* in_size) : index (int_index), size (in_size) {}
+
+    int index;
+    XRRScreenSize* size;
+};
+
+class SizeCompare {
+public:
+    bool operator () (const SizeInfo& size1, const SizeInfo& size2) const
+    {
+        int area1 = size1.size->width * size1.size->height;
+        int area2 = size2.size->width * size2.size->height;
+        return area1 < area2 || (area1 == area2 && size1.index < size2.index);
+    }
+};
+
+void DynamicScreen::set_mode(int width, int height)
+{
+    int num_sizes;
+
+    X_DEBUG_SYNC(get_display());
+    XRRScreenSize* sizes = XRRSizes(get_display(), get_screen(), &num_sizes);
+
+    typedef std::set<SizeInfo, SizeCompare> SizesSet;
+    SizesSet sizes_set;
+
+    for (int i = 0; i < num_sizes; i++) {
+        if (sizes[i].width >= width && sizes[i].height >= height) {
+            sizes_set.insert(SizeInfo(i, &sizes[i]));
+        }
+    }
+    _out_of_sync = true;
+    if (!sizes_set.empty() && set_screen_size((*sizes_set.begin()).index)) {
+        _out_of_sync = false;
+    }
+    X_DEBUG_SYNC(get_display());
+}
+
+void DynamicScreen::restore()
+{
+    X_DEBUG_SYNC(get_display());
+    if (is_broken() || (get_width() == _saved_width && get_height() == _saved_height)) {
+        return;
+    }
+    int num_sizes;
+
+    XRRScreenSize* sizes = XRRSizes(get_display(), get_screen(), &num_sizes);
+    for (int i = 0; i < num_sizes; i++) {
+        if (sizes[i].width == _saved_width && sizes[i].height == _saved_height) {
+            set_screen_size(i);
+            return;
+        }
+    }
+    X_DEBUG_SYNC(get_display());
+    LOG_WARN("can't find startup mode");
+}
+
+bool DynamicScreen::set_screen_size(int size_index)
+{
+    X_DEBUG_SYNC(get_display());
+    Window root_window = RootWindow(get_display(), get_screen());
+    XRRScreenConfiguration* config;
+
+    if (!(config = XRRGetScreenInfo(get_display(), root_window))) {
+        LOG_WARN("get scren info failed");
+        return false;
+    }
+    Rotation rotation;
+    XRRConfigCurrentConfiguration(config, &rotation);
+
+    Monitor::self_monitors_change++;
+    /*what status*/
+    XRRSetScreenConfig(get_display(), config, root_window, size_index, rotation, CurrentTime);
+    process_monitor_configure_events(root_window);
+    Monitor::self_monitors_change--;
+    XRRFreeScreenConfigInfo(config);
+    X_DEBUG_SYNC(get_display());
+
+    int num_sizes;
+    XRRScreenSize* sizes = XRRSizes(get_display(), get_screen(), &num_sizes);
+    if (num_sizes <= size_index) {
+        THROW("invalid sizes size");
+    }
+    set_width(sizes[size_index].width);
+    set_height(sizes[size_index].height);
+    return true;
+}
+
+#ifdef USE_XRANDR_1_2
+
+class MultyMonScreen: public XScreen {
+public:
+    MultyMonScreen(Display* display, int screen, int& next_mon_id);
+    virtual ~MultyMonScreen();
+
+    virtual void publish_monitors(MonitorsList& monitors);
+
+    void disable();
+    void enable();
+
+    bool set_monitor_mode(XMonitor& monitor, const XRRModeInfo& mode_info);
+
+private:
+    void set_size(int width, int height);
+    void get_trans_size(int& width, int& hight);
+    Point get_trans_top_left();
+    Point get_trans_bottom_right();
+    bool changed();
+
+    XMonitor* crtc_overlap_test(int x, int y, int width, int height);
+    void monitors_cleanup();
+    void restore();
+
+private:
+    int _min_width;
+    int _min_height;
+    int _max_width;
+    int _max_height;
+    int _saved_width;
+    int _saved_height;
+    int _saved_width_mm;
+    int _saved_height_mm;
+    XMonitorsList _monitors;
+};
+
+#define MAX_TRANS_DEPTH 3
+
+class XMonitor: public Monitor {
+public:
+    XMonitor(MultyMonScreen& container, int id, RRCrtc crtc);
+    virtual ~XMonitor();
+
+    virtual void set_mode(int width, int height);
+    virtual void restore();
+    virtual int get_depth();
+    virtual Point get_position();
+    virtual Point get_size() const;
+    virtual bool is_out_of_sync();
+    virtual int get_screen_id() { return _container.get_screen();}
+
+    void add_clone(XMonitor *clone);
+    void revert();
+    void disable();
+    void enable();
+
+    void set_mode(const XRRModeInfo& mode);
+    const Rect& get_prev_area();
+    Rect& get_trans_area();
+    void pin() { _pin_count++;}
+    void unpin() { ASSERT(_pin_count > 0); _pin_count--;}
+    bool is_pinned() {return !!_pin_count;}
+    void commit_trans_position();
+    void set_pusher(XMonitor& pusher) { _pusher = &pusher;}
+    XMonitor* get_pusher() { return _pusher;}
+    void push_trans();
+    void begin_trans();
+    bool mode_changed();
+    bool position_changed();
+
+    static void inc_change_ref() { Monitor::self_monitors_change++;}
+    static void dec_change_ref() { Monitor::self_monitors_change--;}
+
+private:
+    void update_position();
+    bool finde_mode_in_outputs(RRMode mode, int start_index, XRRScreenResources* res);
+    bool finde_mode_in_clones(RRMode mode, XRRScreenResources* res);
+    XRRModeInfo* find_mode(int width, int height, XRRScreenResources* res);
+
+private:
+    MultyMonScreen& _container;
+    RRCrtc _crtc;
+    XMonitorsList _clones;
+    Point _position;
+    Point _size;
+    RRMode _mode;
+    Rotation _rotation;
+    int _noutput;
+    RROutput* _outputs;
+
+    Point _saved_position;
+    Point _saved_size;
+    RRMode _saved_mode;
+    Rotation _saved_rotation;
+
+    bool _out_of_sync;
+    RedScreenRotation _red_rotation;
+    RedSubpixelOrder _subpixel_order;
+
+    int _trans_depth;
+    Rect _trans_area[MAX_TRANS_DEPTH];
+    int _pin_count;
+    XMonitor* _pusher;
+};
+
+MultyMonScreen::MultyMonScreen(Display* display, int screen, int& next_mon_id)
+    : XScreen(display, screen)
+    , _saved_width (get_width())
+    , _saved_height (get_height())
+    , _saved_width_mm (DisplayWidthMM(display, screen))
+    , _saved_height_mm (DisplayHeightMM(display, screen))
+{
+    X_DEBUG_SYNC(get_display());
+    Window root_window = RootWindow(display, screen);
+    XRRGetScreenSizeRange(display, root_window, &_min_width, &_min_height,
+                          &_max_width, &_max_height);
+
+    AutoScreenRes res(XRRGetScreenResources(display, root_window));
+    if (!res.valid()) {
+        THROW("get screen resources failed");
+    }
+
+#ifdef SHOW_SCREEN_INFO
+    show_scren_info();
+#endif
+    try {
+        for (int i = 0; i < res->ncrtc; i++) {
+            AutoCrtcInfo crtc_info(XRRGetCrtcInfo(display, res.get(), res->crtcs[i]));
+
+            if (!crtc_info.valid()) {
+                THROW("get crtc info failed");
+            }
+
+            if (crtc_info->mode == None) {
+                continue;
+            }
+
+            ASSERT(crtc_info->noutput);
+
+            XMonitor* clone_mon = crtc_overlap_test(crtc_info->x, crtc_info->y,
+                                                    crtc_info->width, crtc_info->height);
+
+            if (clone_mon) {
+                clone_mon->add_clone(new XMonitor(*this, next_mon_id++, res->crtcs[i]));
+                continue;
+            }
+
+            _monitors.push_back(new XMonitor(*this, next_mon_id++, res->crtcs[i]));
+        }
+    } catch (...) {
+        monitors_cleanup();
+        throw;
+    }
+
+    XSelectInput(display, root_window, StructureNotifyMask);
+    XRRSelectInput(display, root_window, RRScreenChangeNotifyMask);
+    XPlatform::set_win_proc(root_window, root_win_proc);
+    X_DEBUG_SYNC(get_display());
+}
+
+MultyMonScreen::~MultyMonScreen()
+{
+    restore();
+    monitors_cleanup();
+}
+
+XMonitor* MultyMonScreen::crtc_overlap_test(int x, int y, int width, int height)
+{
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        XMonitor* mon = *iter;
+
+        Point pos = mon->get_position();
+        Point size = mon->get_size();
+
+        if (x == pos.x && y == pos.y && width == size.x && height == size.y) {
+            return mon;
+        }
+
+        if (x < pos.x + size.x && x + width > pos.x && y < pos.y + size.y && y + height > pos.y) {
+            THROW("unsupported partial overlap");
+        }
+    }
+    return NULL;
+}
+
+void MultyMonScreen::publish_monitors(MonitorsList& monitors)
+{
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        monitors.push_back(*iter);
+    }
+}
+
+void MultyMonScreen::monitors_cleanup()
+{
+    while (!_monitors.empty()) {
+        XMonitor* monitor = _monitors.front();
+        _monitors.pop_front();
+        delete monitor;
+    }
+}
+
+void MultyMonScreen::disable()
+{
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        (*iter)->disable();
+    }
+}
+
+void MultyMonScreen::enable()
+{
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        (*iter)->enable();
+    }
+}
+
+void MultyMonScreen::set_size(int width, int height)
+{
+    X_DEBUG_SYNC(get_display());
+    Window root_window = RootWindow(get_display(), get_screen());
+    set_width(width);
+    int width_mm = (int)((double)_saved_width_mm / _saved_width * width);
+    set_height(height);
+    int height_mm = (int)((double)_saved_height_mm / _saved_height * height);
+    XRRSetScreenSize(get_display(), root_window, width, height, width_mm, height_mm);
+    X_DEBUG_SYNC(get_display());
+}
+
+bool MultyMonScreen::changed()
+{
+    if (get_width() != _saved_width || get_height() != _saved_height) {
+        return true;
+    }
+
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        if ((*iter)->mode_changed() || (*iter)->position_changed()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void MultyMonScreen::restore()
+{
+    if (is_broken() || !changed()) {
+        return;
+    }
+    X_DEBUG_SYNC(get_display());
+    XMonitor::inc_change_ref();
+    disable();
+    Window root_window = RootWindow(get_display(), get_screen());
+
+    XRRSetScreenSize(get_display(), root_window, _saved_width,
+                     _saved_height,
+                     _saved_width_mm, _saved_height_mm);
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        (*iter)->revert();
+    }
+    enable();
+    process_monitor_configure_events(root_window);
+    XMonitor::dec_change_ref();
+    X_DEBUG_SYNC(get_display());
+}
+
+Point MultyMonScreen::get_trans_top_left()
+{
+    Point position;
+    position.y = position.x = MAXINT;
+
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        Rect& area = (*iter)->get_trans_area();
+        position.x = MIN(position.x, area.left);
+        position.y = MIN(position.y, area.top);
+    }
+    return position;
+}
+
+Point MultyMonScreen::get_trans_bottom_right()
+{
+    Point position;
+    position.y = position.x = MININT;
+
+    XMonitorsList::iterator iter = _monitors.begin();
+    for (; iter != _monitors.end(); iter++) {
+        Rect& area = (*iter)->get_trans_area();
+        position.x = MAX(position.x, area.right);
+        position.y = MAX(position.y, area.bottom);
+    }
+    return position;
+}
+
+void MultyMonScreen::get_trans_size(int& width, int& height)
+{
+    ASSERT(get_trans_top_left().x == 0 && get_trans_top_left().y == 0);
+    Point bottom_right = get_trans_bottom_right();
+    ASSERT(bottom_right.x > 0 && bottom_right.y > 0);
+    width = bottom_right.x;
+    height = bottom_right.y;
+}
+
+#endif
+
+/*class Variant {
+    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    static int get_head(const Rect& area)
+    static int get_tail(const Rect& area)
+    static void move_head(Rect& area, int delta)
+    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    static void offset(Rect& area, int delta)
+    static void shrink(Rect& area, int delta)
+    static int get_distance(const Rect& area, const Rect& other_area)
+    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+}*/
+
+#ifdef USE_XRANDR_1_2
+
+class SortRightToLeft {
+public:
+    bool operator () (XMonitor* mon1, XMonitor* mon2) const
+    {
+        return mon1->get_trans_area().right > mon2->get_trans_area().right;
+    }
+};
+
+typedef std::multiset<XMonitor*, SortRightToLeft> PushLeftSet;
+
+class LeftVariant {
+public:
+
+    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    {
+        area.right = base.left;
+        area.left = area.right - size;
+        area.bottom = base.bottom;
+        area.top = base.top;
+    }
+
+    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    {
+        return other.right - fix_area.left;
+    }
+
+    static int get_head(const Rect& area)
+    {
+        return area.left;
+    }
+
+    static int get_tail(const Rect& area)
+    {
+        return area.right;
+    }
+
+    static void move_head(Rect& area, int delta)
+    {
+        area.left -= delta;
+        ASSERT(area.right >= area.left);
+    }
+
+    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    {
+        return other.left - fix_area.right;
+    }
+
+    static void offset(Rect& area, int delta)
+    {
+        rect_offset(area, -delta, 0);
+    }
+
+    static void shrink(Rect& area, int delta)
+    {
+        area.right -= delta;
+        ASSERT(area.right > area.left);
+    }
+
+    static int get_distance(const Rect& area, const Rect& other_area)
+    {
+        return other_area.left - area.left;
+    }
+
+    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    {
+        return area.right == other_area.left && other_area.top < area.bottom &&
+               other_area.bottom > area.top;
+    }
+
+    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    {
+        return (other_area.bottom == area.top || other_area.top == area.bottom) &&
+               other_area.left < area.right && other_area.right > area.left;
+    }
+};
+
+class SortLeftToRight {
+public:
+    bool operator () (XMonitor* mon1, XMonitor* mon2) const
+    {
+        return mon1->get_trans_area().left < mon2->get_trans_area().left;
+    }
+};
+
+typedef std::multiset<XMonitor*, SortLeftToRight> PushRightSet;
+
+class RightVariant {
+public:
+
+    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    {
+        area.left = base.right;
+        area.right = area.left + size;
+        area.top = base.top;
+        area.bottom = base.bottom;
+    }
+
+    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    {
+        return fix_area.right - other.left;
+    }
+
+    static int get_head(const Rect& area)
+    {
+        return area.right;
+    }
+
+    static int get_tail(const Rect& area)
+    {
+        return area.left;
+    }
+
+    static void move_head(Rect& area, int delta)
+    {
+        area.right += delta;
+        ASSERT(area.right >= area.left);
+    }
+
+    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    {
+        return fix_area.left - other.right;
+    }
+
+    static void offset(Rect& area, int delta)
+    {
+        rect_offset(area, delta, 0);
+    }
+
+    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    {
+        return other_area.right == area.left && other_area.top < area.bottom &&
+               other_area.bottom > area.top;
+    }
+
+    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    {
+        return (other_area.bottom == area.top || other_area.top == area.bottom) &&
+               other_area.left < area.right && other_area.right > area.left;
+    }
+};
+
+class SortBottomToTop {
+public:
+    bool operator () (XMonitor* mon1, XMonitor* mon2) const
+    {
+        return mon1->get_trans_area().bottom > mon2->get_trans_area().bottom;
+    }
+};
+
+typedef std::multiset<XMonitor*, SortBottomToTop> PushTopSet;
+
+class TopVariant {
+public:
+    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    {
+        area.left = base.left;
+        area.right = base.right;
+        area.bottom = base.top;
+        area.top = area.bottom - size;
+    }
+
+    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    {
+        return other.bottom - fix_area.top;
+    }
+
+    static int get_head(const Rect& area)
+    {
+        return area.top;
+    }
+
+    static int get_tail(const Rect& area)
+    {
+        return area.bottom;
+    }
+
+    static void move_head(Rect& area, int delta)
+    {
+        area.top -= delta;
+        ASSERT(area.bottom >= area.top);
+    }
+
+    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    {
+        return other.top - fix_area.bottom;
+    }
+
+    static void offset(Rect& area, int delta)
+    {
+        rect_offset(area, 0, -delta);
+    }
+
+    static void shrink(Rect& area, int delta)
+    {
+        area.bottom -= delta;
+        ASSERT(area.bottom > area.top);
+    }
+
+    static int get_distance(const Rect& area, const Rect& other_area)
+    {
+        return other_area.top - area.top;
+    }
+
+    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    {
+        return area.bottom == other_area.top && other_area.left < area.right &&
+               other_area.right > area.left;
+    }
+
+    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    {
+        return (other_area.right == area.left || other_area.left == area.right) &&
+               other_area.top < area.bottom && other_area.bottom > area.top;
+    }
+};
+
+class SortTopToBottom {
+public:
+    bool operator () (XMonitor* mon1, XMonitor* mon2) const
+    {
+        return mon1->get_trans_area().top < mon2->get_trans_area().top;
+    }
+};
+
+typedef std::multiset<XMonitor*, SortTopToBottom> PushBottomSet;
+
+class BottomVariant {
+public:
+
+    static void get_area_in_front(const Rect& base, int size, Rect& area)
+    {
+        area.left = base.left;
+        area.right = base.right;
+        area.top = base.bottom;
+        area.bottom = area.top + size;
+    }
+
+    static int get_push_distance(const Rect& fix_area, const Rect& other)
+    {
+        return fix_area.bottom - other.top;
+    }
+
+    static int get_head(const Rect& area)
+    {
+        return area.bottom;
+    }
+
+    static int get_tail(const Rect& area)
+    {
+        return area.top;
+    }
+
+    static void move_head(Rect& area, int delta)
+    {
+        area.bottom += delta;
+        ASSERT(area.bottom >= area.top);
+    }
+
+    static int get_pull_distance(const Rect& fix_area, const Rect& other)
+    {
+        return fix_area.top - other.bottom;
+    }
+
+    static void offset(Rect& area, int delta)
+    {
+        rect_offset(area, 0, delta);
+    }
+
+    static bool is_on_tail(const Rect& area, const Rect& other_area)
+    {
+        return other_area.bottom == area.top && other_area.left < area.right &&
+               other_area.right > area.left;
+    }
+
+    static bool is_on_perpendiculars(const Rect& area, const Rect& other_area)
+    {
+        return (other_area.right == area.left || other_area.left == area.right) &&
+               other_area.top < area.bottom && other_area.bottom > area.top;
+    }
+};
+
+volatile int wait_for_me = false;
+
+template <class Variant>
+static void bounce_back(XMonitor& monitor, const XMonitorsList& monitors, int head, int distance)
+{
+    ASSERT(distance > 0);
+    while (wait_for_me);
+
+    for (XMonitorsList::const_iterator iter = monitors.begin(); iter != monitors.end(); iter++) {
+        Rect& area = (*iter)->get_trans_area();
+        if (Variant::get_tail(area) == head && (*iter)->get_pusher() == &monitor) {
+            Variant::offset(area, -distance);
+            bounce_back<Variant>(**iter, monitors, Variant::get_head(area) + distance, distance);
+            //todo: pull_back monitors on perpendiculars
+        }
+    }
+}
+
+template <class Variant, class SortList, class SortListIter>
+static int push(XMonitor& pusher, XMonitor& monitor, const XMonitorsList& monitors, int delta)
+{
+    monitor.pin();
+    monitor.set_pusher(pusher);
+
+    SortList sort;
+    XMonitorsList::const_iterator iter = monitors.begin();
+    for (; iter != monitors.end(); iter++) {
+        if (*iter == &monitor) {
+            continue;
+        }
+        sort.insert(*iter);
+    }
+
+    Rect area_to_clear;
+    Variant::get_area_in_front(monitor.get_trans_area(), delta, area_to_clear);
+
+    SortListIter sort_iter = sort.begin();
+
+    for (; sort_iter != sort.end(); sort_iter++) {
+        const Rect& other_area = (*sort_iter)->get_trans_area();
+
+        if (rect_intersects(area_to_clear, other_area)) {
+            int distance = Variant::get_push_distance(area_to_clear, other_area);
+            ASSERT(distance > 0);
+            if (!(*sort_iter)->is_pinned()) {
+                distance = distance - push<Variant, SortList, SortListIter>(monitor, **sort_iter,
+                                                                            monitors, distance);
+            }
+
+            if (distance) {
+                delta -= distance;
+                bounce_back<Variant>(monitor, monitors, Variant::get_head(area_to_clear), distance);
+                Variant::move_head(area_to_clear, -distance);
+            }
+        }
+    }
+    Variant::offset(monitor.get_trans_area(), delta);
+
+    const Rect& area = monitor.get_prev_area();
+    for (iter = monitors.begin(); iter != monitors.end(); iter++) {
+        if ((*iter)->is_pinned()) {
+            continue;
+        }
+
+        const Rect& other_area = (*iter)->get_prev_area();
+        if (Variant::is_on_perpendiculars(area, other_area)) {
+            int current_distance = Variant::get_pull_distance(monitor.get_trans_area(),
+                                                              (*iter)->get_trans_area());
+            int base_distance = Variant::get_pull_distance(area, other_area);
+            int distance = current_distance - base_distance;
+            if (distance > 0) {
+                push<Variant, SortList, SortListIter>(monitor, **iter, monitors, distance);
+            }
+        } else if (Variant::is_on_tail(area, other_area)) {
+            int distance = Variant::get_pull_distance(monitor.get_trans_area(),
+                                                      (*iter)->get_trans_area());
+            ASSERT(distance >= 0);
+            push<Variant, SortList, SortListIter>(monitor, **iter, monitors, distance);
+        }
+    }
+    return delta;
+}
+
+template <class Variant>
+static void pin(XMonitor& monitor, const XMonitorsList& monitors)
+{
+    const Rect& area = monitor.get_trans_area();
+
+    for (XMonitorsList::const_iterator iter = monitors.begin(); iter != monitors.end(); iter++) {
+        const Rect& other_area = (*iter)->get_trans_area();
+        if ((*iter)->is_pinned()) {
+            continue;
+        }
+        if (Variant::is_on_tail(other_area, area) ||
+                                                  Variant::is_on_perpendiculars(area, other_area)) {
+            (*iter)->pin();
+            pin<Variant>(**iter, monitors);
+        }
+    }
+}
+
+template <class Variant, class SortList, class SortListIter>
+static void shrink(XMonitor& monitor, const XMonitorsList& monitors, int delta)
+{
+    monitor.pin();
+    pin<Variant>(monitor, monitors);
+    ASSERT(delta > 0);
+
+    SortList sort;
+    XMonitorsList::const_iterator iter = monitors.begin();
+    for (; iter != monitors.end(); iter++) {
+        if (*iter == &monitor) {
+            continue;
+        }
+        sort.insert(*iter);
+    }
+
+    const Rect area = monitor.get_trans_area();
+    Variant::shrink(monitor.get_trans_area(), delta);
+    for (SortListIter sort_iter = sort.begin(); sort_iter != sort.end(); sort_iter++) {
+        const Rect& other_area = (*sort_iter)->get_trans_area();
+        if (Variant::is_on_perpendiculars(area, other_area)) {
+            int distance = Variant::get_distance(area, other_area);
+            if (distance > 0) {
+                distance = MIN(distance, delta);
+                push<Variant, SortList, SortListIter>(monitor, **sort_iter, monitors, distance);
+            }
+        } else if (Variant::is_on_tail(area, other_area)) {
+            push<Variant, SortList, SortListIter>(monitor, **sort_iter, monitors, delta);
+        }
+    }
+}
+
+template <class Variant, class SortList, class SortListIter>
+static void expand(XMonitor& monitor, const XMonitorsList& monitors, int delta)
+{
+    monitor.pin();
+    ASSERT(delta > 0);
+
+    SortList sort;
+    XMonitorsList::const_iterator iter = monitors.begin();
+    for (; iter != monitors.end(); iter++) {
+        if (*iter == &monitor) {
+            continue;
+        }
+        sort.insert(*iter);
+    }
+
+    Rect area_to_clear;
+    Variant::get_area_in_front(monitor.get_trans_area(), delta, area_to_clear);
+
+    for (SortListIter sort_iter = sort.begin(); sort_iter != sort.end(); sort_iter++) {
+        const Rect& other_area = (*sort_iter)->get_trans_area();
+
+        if (rect_intersects(area_to_clear, other_area)) {
+            int distance = Variant::get_push_distance(area_to_clear, other_area);
+            ASSERT(distance > 0);
+            ASSERT(!(*sort_iter)->is_pinned());
+#ifdef RED_DEBUG
+            int actual =
+#endif
+            push<Variant, SortList, SortListIter>(monitor, **sort_iter, monitors, distance);
+            ASSERT(actual == distance);
+        }
+    }
+    Variant::move_head(monitor.get_trans_area(), delta);
+}
+
+bool MultyMonScreen::set_monitor_mode(XMonitor& monitor, const XRRModeInfo& mode_info)
+{
+    if (is_broken()) {
+        return false;
+    }
+
+    Point size = monitor.get_size();
+    int dx = mode_info.width - size.x;
+    int dy = mode_info.height - size.y;
+
+    XMonitorsList::iterator iter = _monitors.begin();
+
+    for (; iter != _monitors.end(); iter++) {
+        (*iter)->begin_trans();
+    }
+
+    if (dx > 0) {
+        expand<RightVariant, PushRightSet, PushRightSet::iterator>(monitor, _monitors, dx);
+    } else if (dx < 0) {
+        shrink<LeftVariant, PushLeftSet, PushLeftSet::iterator>(monitor, _monitors, -dx);
+    }
+
+    for (iter = _monitors.begin(); iter != _monitors.end(); iter++) {
+        (*iter)->push_trans();
+    }
+
+    if (dy > 0) {
+        expand<BottomVariant, PushBottomSet, PushBottomSet::iterator>(monitor, _monitors, dy);
+    } else if (dy < 0) {
+        shrink<TopVariant, PushTopSet, PushTopSet::iterator>(monitor, _monitors, -dy);
+    }
+
+    int screen_width;
+    int screen_height;
+
+    get_trans_size(screen_width, screen_height);
+
+    if (screen_width > _max_width || screen_height > _max_height) {
+        return false;
+    }
+
+    screen_width = MAX(screen_width, _min_width);
+    screen_height = MAX(screen_height, _min_height);
+
+    XMonitor::inc_change_ref();
+    disable();
+    for (iter = _monitors.begin(); iter != _monitors.end(); iter++) {
+        (*iter)->commit_trans_position();
+    }
+    X_DEBUG_SYNC(get_display());
+    monitor.set_mode(mode_info);
+    set_size(screen_width, screen_height);
+    enable();
+    Window root_window = RootWindow(get_display(), get_screen());
+    process_monitor_configure_events(root_window);
+    XMonitor::dec_change_ref();
+    X_DEBUG_SYNC(get_display());
+    return true;
+}
+
+XMonitor::XMonitor(MultyMonScreen& container, int id, RRCrtc crtc)
+    : Monitor(id)
+    , _container (container)
+    , _crtc (crtc)
+    , _out_of_sync (false)
+{
+    update_position();
+    _saved_position = _position;
+    _saved_size = _size;
+    _saved_mode = _mode;
+    _saved_rotation = _rotation;
+}
+
+XMonitor::~XMonitor()
+{
+    while (!_clones.empty()) {
+        XMonitor* clone = _clones.front();
+        _clones.pop_front();
+        delete clone;
+    }
+    delete[] _outputs;
+}
+
+void XMonitor::update_position()
+{
+    Display* display = _container.get_display();
+    X_DEBUG_SYNC(display);
+    Window root_window = RootWindow(display, _container.get_screen());
+    AutoScreenRes res(XRRGetScreenResources(display, root_window));
+
+    if (!res.valid()) {
+        THROW("get screen resources failed");
+    }
+
+    AutoCrtcInfo crtc_info(XRRGetCrtcInfo(display, res.get(), _crtc));
+
+    ASSERT(crtc_info->noutput);
+
+    _position.x = crtc_info->x;
+    _position.y = crtc_info->y;
+    _size.x = crtc_info->width;
+    _size.y = crtc_info->height;
+
+    switch (crtc_info->rotation & 0xf) {
+    case RR_Rotate_0:
+        _red_rotation = RED_SCREEN_ROTATION_0;
+        break;
+    case RR_Rotate_90:
+        _red_rotation = RED_SCREEN_ROTATION_90;
+        break;
+    case RR_Rotate_180:
+        _red_rotation = RED_SCREEN_ROTATION_180;
+        break;
+    case RR_Rotate_270:
+        _red_rotation = RED_SCREEN_ROTATION_270;
+        break;
+    default:
+        THROW("invalid rotation");
+    }
+
+    if (crtc_info->noutput > 1) {
+        _subpixel_order = RED_SUBPIXEL_ORDER_UNKNOWN;
+        return;
+    }
+
+    AutoOutputInfo output_info(XRRGetOutputInfo(display, res.get(), crtc_info->outputs[0]));
+
+    switch (output_info->subpixel_order) {
+    case SubPixelUnknown:
+        _subpixel_order = RED_SUBPIXEL_ORDER_UNKNOWN;
+        break;
+    case SubPixelHorizontalRGB:
+        _subpixel_order = RED_SUBPIXEL_ORDER_H_RGB;
+        break;
+    case SubPixelHorizontalBGR:
+        _subpixel_order = RED_SUBPIXEL_ORDER_H_BGR;
+        break;
+    case SubPixelVerticalRGB:
+        _subpixel_order = RED_SUBPIXEL_ORDER_V_RGB;
+        break;
+    case SubPixelVerticalBGR:
+        _subpixel_order = RED_SUBPIXEL_ORDER_V_BGR;
+        break;
+    case SubPixelNone:
+        _subpixel_order = RED_SUBPIXEL_ORDER_NONE;
+        break;
+    default:
+        THROW("invalid subpixel order");
+    }
+
+    _mode = crtc_info->mode;
+    _rotation = crtc_info->rotation;
+    _noutput = crtc_info->noutput;
+    _outputs = new RROutput[_noutput];
+    memcpy(_outputs, crtc_info->outputs, _noutput * sizeof(RROutput));
+    X_DEBUG_SYNC(display);
+}
+
+bool XMonitor::finde_mode_in_outputs(RRMode mode, int start_index, XRRScreenResources* res)
+{
+    int i, j;
+
+    X_DEBUG_SYNC(_container.get_display());
+    for (i = start_index; i < _noutput; i++) {
+        AutoOutputInfo output_info(XRRGetOutputInfo(_container.get_display(), res, _outputs[i]));
+        for (j = 0; j < output_info->nmode; j++) {
+            if (output_info->modes[j] == mode) {
+                break;
+            }
+        }
+        if (j == output_info->nmode) {
+            return false;
+        }
+    }
+    X_DEBUG_SYNC(_container.get_display());
+    return true;
+}
+
+bool XMonitor::finde_mode_in_clones(RRMode mode, XRRScreenResources* res)
+{
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        if (!(*iter)->finde_mode_in_outputs(mode, 0, res)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+class ModeInfo {
+public:
+    ModeInfo(int int_index, XRRModeInfo* in_info) : index (int_index), info (in_info) {}
+
+    int index;
+    XRRModeInfo* info;
+};
+
+class ModeCompare {
+public:
+    bool operator () (const ModeInfo& mode1, const ModeInfo& mode2) const
+    {
+        int area1 = mode1.info->width * mode1.info->height;
+        int area2 = mode2.info->width * mode2.info->height;
+        return area1 < area2 || (area1 == area2 && mode1.index < mode2.index);
+    }
+};
+
+XRRModeInfo* XMonitor::find_mode(int width, int height, XRRScreenResources* res)
+{
+    typedef std::set<ModeInfo, ModeCompare> ModesSet;
+    ModesSet modes_set;
+    X_DEBUG_SYNC(_container.get_display());
+    AutoOutputInfo output_info(XRRGetOutputInfo(_container.get_display(), res, _outputs[0]));
+    for (int i = 0; i < output_info->nmode; i++) {
+        XRRModeInfo* mode_inf = find_mod(res, output_info->modes[i]);
+        if (mode_inf->width >= width && mode_inf->height >= height) {
+            modes_set.insert(ModeInfo(i, mode_inf));
+        }
+    }
+
+    while (!modes_set.empty()) {
+        ModesSet::iterator iter = modes_set.begin();
+
+        if (!finde_mode_in_outputs((*iter).info->id, 1, res)) {
+            modes_set.erase(iter);
+            continue;
+        }
+
+        if (!finde_mode_in_clones((*iter).info->id, res)) {
+            modes_set.erase(iter);
+            continue;
+        }
+        return (*iter).info;
+    }
+    X_DEBUG_SYNC(_container.get_display());
+    return NULL;
+}
+
+void XMonitor::set_mode(int width, int height)
+{
+    if (width == _size.x && height == _size.y) {
+        _out_of_sync = false;
+        return;
+    }
+    Display* display = _container.get_display();
+    X_DEBUG_SYNC(display);
+    Window root_window = RootWindow(display, _container.get_screen());
+    AutoScreenRes res(XRRGetScreenResources(display, root_window));
+    if (!res.valid()) {
+        THROW("get screen resource failed");
+    }
+    XRRModeInfo* mode_info = find_mode(width, height, res.get());
+
+    if (!mode_info || !_container.set_monitor_mode(*this, *mode_info)) {
+        _out_of_sync = true;
+        X_DEBUG_SYNC(display);
+        return;
+    }
+    _out_of_sync = false;
+}
+
+void XMonitor::revert()
+{
+    _position = _saved_position;
+    _size = _saved_size;
+    _mode = _saved_mode;
+    _rotation = _saved_rotation;
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        (*iter)->revert();
+    }
+}
+
+void XMonitor::disable()
+{
+    Display* display = _container.get_display();
+    X_DEBUG_SYNC(display);
+    Window root_window = RootWindow(display, _container.get_screen());
+    AutoScreenRes res(XRRGetScreenResources(display, root_window));
+    if (!res.valid()) {
+        THROW("get screen resources failed");
+    }
+    XRRSetCrtcConfig(display, res.get(), _crtc, CurrentTime,
+                     0, 0, None, RR_Rotate_0, NULL, 0);
+
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        (*iter)->disable();
+    }
+    X_DEBUG_SYNC(display);
+}
+
+void XMonitor::enable()
+{
+    Display* display = _container.get_display();
+    X_DEBUG_SYNC(display);
+    Window root_window = RootWindow(display, _container.get_screen());
+    AutoScreenRes res(XRRGetScreenResources(display, root_window));
+    if (!res.valid()) {
+        THROW("get screen resources failed");
+    }
+    XRRSetCrtcConfig(display, res.get(), _crtc, CurrentTime,
+                     _position.x, _position.y,
+                     _mode, _rotation,
+                     _outputs, _noutput);
+
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        (*iter)->enable();
+    }
+    X_DEBUG_SYNC(display);
+}
+
+bool XMonitor::mode_changed()
+{
+    return _size.x != _saved_size.x || _size.y != _saved_size.y ||
+           _mode != _saved_mode || _rotation != _saved_rotation;
+}
+
+bool XMonitor::position_changed()
+{
+    return _position.x != _saved_position.x || _position.y != _saved_position.y;
+}
+
+void XMonitor::restore()
+{
+    if (!mode_changed()) {
+        return;
+    }
+    set_mode(_saved_size.x, _saved_size.y);
+}
+
+int XMonitor::get_depth()
+{
+    return XPlatform::get_vinfo()[0]->depth;
+}
+
+Point XMonitor::get_position()
+{
+    return _position;
+}
+
+Point XMonitor::get_size() const
+{
+    return _size;
+}
+
+bool XMonitor::is_out_of_sync()
+{
+    return _out_of_sync;
+}
+
+void XMonitor::add_clone(XMonitor *clone)
+{
+    _clones.push_back(clone);
+}
+
+const Rect& XMonitor::get_prev_area()
+{
+    return _trans_area[_trans_depth - 1];
+}
+
+Rect& XMonitor::get_trans_area()
+{
+    return _trans_area[_trans_depth];
+}
+
+void XMonitor::push_trans()
+{
+    _trans_depth++;
+    ASSERT(_trans_depth < MAX_TRANS_DEPTH);
+    _trans_area[_trans_depth] = _trans_area[_trans_depth - 1];
+    _pin_count = 0;
+    _pusher = NULL;
+}
+
+void XMonitor::begin_trans()
+{
+    _trans_area[0].left = _position.x;
+    _trans_area[0].right = _trans_area[0].left + _size.x;
+    _trans_area[0].top = _position.y;
+    _trans_area[0].bottom = _trans_area[0].top + _size.y;
+    _trans_area[1] = _trans_area[0];
+    _trans_depth = 1;
+    _pin_count = 0;
+    _pusher = NULL;
+}
+
+void XMonitor::commit_trans_position()
+{
+    _position.x = _trans_area[_trans_depth].left;
+    _position.y = _trans_area[_trans_depth].top;
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        (*iter)->_position = _position;
+    }
+}
+
+void XMonitor::set_mode(const XRRModeInfo& mode)
+{
+    _mode = mode.id;
+    _size.x = mode.width;
+    _size.y = mode.height;
+    XMonitorsList::iterator iter = _clones.begin();
+    for (; iter != _clones.end(); iter++) {
+        (*iter)->set_mode(mode);
+    }
+}
+
+#endif
+
+static MonitorsList monitors;
+
+typedef std::list<XScreen*> ScreenList;
+static ScreenList screens;
+
+const MonitorsList& Platform::init_monitors()
+{
+    int next_mon_id = 0;
+    ASSERT(screens.empty());
+#ifdef USE_XRANDR_1_2
+    if (using_xrandr_1_2) {
+        for (int i = 0; i < ScreenCount(x_display); i++) {
+            screens.push_back(new MultyMonScreen(x_display, i, next_mon_id));
+        }
+    } else
+#endif
+    if (using_xrandr_1_0) {
+        for (int i = 0; i < ScreenCount(x_display); i++) {
+            screens.push_back(new DynamicScreen(x_display, i, next_mon_id));
+        }
+    } else {
+        for (int i = 0; i < ScreenCount(x_display); i++) {
+            screens.push_back(new StaticScreen(x_display, i, next_mon_id));
+        }
+    }
+
+    ASSERT(monitors.empty());
+    ScreenList::iterator iter = screens.begin();
+    for (; iter != screens.end(); iter++) {
+        (*iter)->publish_monitors(monitors);
+    }
+    return monitors;
+}
+
+void Platform::destroy_monitors()
+{
+    monitors.clear();
+    while (!screens.empty()) {
+        XScreen* screen = screens.front();
+        screens.pop_front();
+        delete screen;
+    }
+}
+
+bool Platform::is_monitors_pos_valid()
+{
+    return (ScreenCount(x_display) == 1);
+}
+
+static void root_win_proc(XEvent& event)
+{
+#ifdef USE_XRANDR_1_2
+    ASSERT(using_xrandr_1_0 || using_xrandr_1_2);
+#else
+    ASSERT(using_xrandr_1_0);
+#endif
+    if (event.type == ConfigureNotify || event.type - xrandr_event_base == RRScreenChangeNotify) {
+        XRRUpdateConfiguration(&event);
+        if (event.type - xrandr_event_base == RRScreenChangeNotify) {
+            display_mode_listener->on_display_mode_change();
+        }
+
+        if (Monitor::is_self_change()) {
+            return;
+        }
+
+        ScreenList::iterator iter = screens.begin();
+        for (; iter != screens.end(); iter++) {
+            (*iter)->set_broken();
+        }
+        event_listener->on_monitors_change();
+    }
+
+    /*switch (event.type - xrandr_event_base) {
+    case RRScreenChangeNotify:
+        //XRRScreenChangeNotifyEvent * = (XRRScreenChangeNotifyEvent *) &event;
+        XRRUpdateConfiguration(&event);
+        break;
+    }*/
+}
+
+static void process_monitor_configure_events(Window root)
+{
+    XSync(x_display, False);
+    XEvent event;
+
+    while (XCheckTypedWindowEvent(x_display, root, ConfigureNotify, &event)) {
+        root_win_proc(event);
+    }
+
+    while (XCheckTypedWindowEvent(x_display, root, xrandr_event_base + RRScreenChangeNotify,
+                                  &event)) {
+        root_win_proc(event);
+    }
+}
+
+static void cleanup(void)
+{
+    int i;
+
+    DBG(0, "");
+    if (!Monitor::is_self_change()) {
+        Platform::destroy_monitors();
+    }
+    if (vinfo) {
+        for (i = 0; i < ScreenCount(x_display); ++i) {
+            XFree(vinfo[i]);
+        }
+        delete vinfo;
+        vinfo = NULL;
+    }
+    if (fb_config) {
+        for (i = 0; i < ScreenCount(x_display); ++i) {
+            XFree(fb_config[i]);
+        }
+        delete fb_config;
+        fb_config = NULL;
+    }
+}
+
+static void quit_handler(int sig)
+{
+    LOG_INFO("signal %d", sig);
+    Platform::send_quit_request();
+}
+
+static void abort_handler(int sig)
+{
+    LOG_INFO("signal %d", sig);
+    Platform::destroy_monitors();
+}
+
+static void init_xrandr()
+{
+    Bool xrandr_ext = XRRQueryExtension(x_display, &xrandr_event_base, &xrandr_error_base);
+    if (xrandr_ext) {
+        XRRQueryVersion(x_display, &xrandr_major, &xrandr_minor);
+        if (xrandr_major < 1) {
+            return;
+        }
+#ifdef USE_XRANDR_1_2
+        if (xrandr_major == 1 && xrandr_minor < 2) {
+            using_xrandr_1_0 = true;
+            return;
+        }
+        using_xrandr_1_2 = true;
+#else
+        using_xrandr_1_0 = true;
+#endif
+    }
+}
+
+static void init_xrender()
+{
+    int event_base;
+    int error_base;
+    int major;
+    int minor;
+
+    using_xrender_0_5 = XRenderQueryExtension(x_display, &event_base, &error_base) &&
+        XRenderQueryVersion(x_display, &major, &minor) && (major > 0 || minor >= 5);
+}
+
+unsigned int get_modifier_mask(KeySym modifier)
+{
+    int mask = 0;
+    int i;
+
+    XModifierKeymap* map = XGetModifierMapping(x_display);
+    KeyCode keycode = XKeysymToKeycode(x_display, modifier);
+    if (keycode == NoSymbol) {
+        return 0;
+    }
+
+    for (i = 0; i < 8; i++) {
+        if (map->modifiermap[map->max_keypermod * i] == keycode) {
+            mask = 1 << i;
+        }
+    }
+    XFreeModifiermap(map);
+    return mask;
+}
+
+static void init_kbd()
+{
+    int xkb_major = XkbMajorVersion;
+    int xkb_minor = XkbMinorVersion;
+    int opcode;
+    int event;
+    int error;
+
+    if (!XkbLibraryVersion(&xkb_major, &xkb_minor) ||
+        !XkbQueryExtension(x_display, &opcode, &event, &error, &xkb_major, &xkb_minor)) {
+        return;
+    }
+    caps_lock_mask = get_modifier_mask(XK_Caps_Lock);
+    num_lock_mask = get_modifier_mask(XK_Num_Lock);
+}
+
+static int x_error_handler(Display* display, XErrorEvent* error_event)
+{
+    char error_str[256];
+    char request_str[256];
+    char number_str[32];
+
+    char* display_name = XDisplayString(display);
+    XGetErrorText(display, error_event->error_code, error_str, sizeof(error_str));
+
+    if (error_event->request_code < 128) {
+        snprintf(number_str, sizeof(number_str), "%d", error_event->request_code);
+        XGetErrorDatabaseText(display, "XRequest", number_str, "",
+                              request_str, sizeof(request_str));
+    } else {
+        snprintf(request_str, sizeof(request_str), "%d", error_event->request_code);
+    }
+
+    LOG_ERROR("x error on display %s error %s minor %u request %s",
+              display_name,
+              error_str,
+              (uint32_t)error_event->minor_code,
+              request_str);
+    exit(-1);
+    return 0;
+}
+
+static int x_io_error_handler(Display* display)
+{
+    LOG_ERROR("x io error on %s", XDisplayString(display));
+    exit(-1);
+    return 0;
+}
+
+static XVisualInfo* get_x_vis_info(int screen)
+{
+    XVisualInfo vtemplate;
+    int count;
+
+    Visual* visual = DefaultVisualOfScreen(ScreenOfDisplay(x_display, screen));
+    vtemplate.screen = screen;
+    vtemplate.visualid = XVisualIDFromVisual(visual);
+    return XGetVisualInfo(x_display, VisualIDMask | VisualScreenMask, &vtemplate, &count);
+}
+
+void Platform::init()
+{
+    int err, ev;
+    int threads_enable;
+    XEventHandler *x_event_handler;
+
+    DBG(0, "");
+
+    threads_enable = XInitThreads();
+
+    main_thread = pthread_self();
+
+    if (!(x_display = XOpenDisplay(NULL))) {
+        THROW("open X display failed");
+    }
+
+    vinfo = new XVisualInfo *[ScreenCount(x_display)];
+    memset(vinfo, 0, sizeof(XVisualInfo *) * ScreenCount(x_display));
+    fb_config = new GLXFBConfig *[ScreenCount(x_display)];
+    memset(fb_config, 0, sizeof(GLXFBConfig *) * ScreenCount(x_display));
+
+    // working with KDE and visual from glXGetVisualFromFBConfig is not working
+    // well. for now disabling OGL.
+    if (0 && threads_enable && glXQueryExtension(x_display, &err, &ev)) {
+        int num_configs;
+        int attrlist[] = {
+            GLX_RENDER_TYPE, GLX_RGBA_BIT,
+            GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT | GLX_WINDOW_BIT,
+            GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
+            GLX_RED_SIZE, 8,
+            GLX_GREEN_SIZE, 8,
+            GLX_BLUE_SIZE, 8,
+            GLX_ALPHA_SIZE, 8,
+            GLX_STENCIL_SIZE, 4,
+            GLX_DEPTH_SIZE, 0,
+            None
+        };
+
+        for (int i = 0; i < ScreenCount(x_display); ++i) {
+            if (!(fb_config[i] = glXChooseFBConfig(x_display, i, attrlist, &num_configs))) {
+                vinfo[i] = get_x_vis_info(i);
+            } else {
+                ASSERT(num_configs > 0);
+                vinfo[i] = glXGetVisualFromFBConfig(x_display, fb_config[i][0]);
+            }
+
+            if (!vinfo[i]) {
+                THROW("XGetVisualInfo failed");
+            }
+        }
+    } else {
+        for (int i = 0; i < ScreenCount(x_display); ++i) {
+            if (!(vinfo[i] = get_x_vis_info(i))) {
+                THROW("XGetVisualInfo failed");
+            }
+        }
+    }
+
+    XSetErrorHandler(x_error_handler);
+    XSetIOErrorHandler(x_io_error_handler);
+
+    win_proc_context = XUniqueContext();
+
+    init_kbd();
+    init_xrandr();
+    init_xrender();
+
+    x_event_handler = new XEventHandler(*x_display);
+    events_loop.add_file(*x_event_handler);
+    events_loop.add_trigger(wakeup_handler);
+
+    struct sigaction act;
+    memset(&act, 0, sizeof(act));
+    sigfillset(&act.sa_mask);
+
+    act.sa_handler = quit_handler;
+    sigaction(SIGINT, &act, NULL);
+    sigaction(SIGHUP, &act, NULL);
+    sigaction(SIGTERM, &act, NULL);
+    sigaction(SIGQUIT, &act, NULL);
+
+    act.sa_handler = SIG_IGN;
+    sigaction(SIGPIPE, &act, NULL);
+
+    act.sa_flags = SA_RESETHAND;
+    act.sa_handler = abort_handler;
+    sigaction(SIGABRT, &act, NULL);
+    sigaction(SIGILL, &act, NULL);
+    sigaction(SIGSEGV, &act, NULL);
+    sigaction(SIGFPE, &act, NULL);
+
+    atexit(cleanup);
+}
+
+uint32_t Platform::get_keyboard_modifiers()
+{
+    XKeyboardState keyboard_state;
+    uint32_t modifiers = 0;
+
+    XGetKeyboardControl(x_display, &keyboard_state);
+
+    if (keyboard_state.led_mask & 0x01) {
+        modifiers |= CAPS_LOCK_MODIFIER;
+    }
+    if (keyboard_state.led_mask & 0x02) {
+        modifiers |= NUM_LOCK_MODIFIER;
+    }
+    if (keyboard_state.led_mask & 0x04) {
+        modifiers |= SCROLL_LOCK_MODIFIER;
+    }
+    return modifiers;
+}
+
+enum XLed {
+    X11_CAPS_LOCK_LED = 1,
+    X11_NUM_LOCK_LED,
+    X11_SCROLL_LOCK_LED,
+};
+
+static void  set_keyboard_led(XLed led, int set)
+{
+    switch (led) {
+    case X11_CAPS_LOCK_LED:
+        if (caps_lock_mask) {
+            XkbLockModifiers(x_display, XkbUseCoreKbd, caps_lock_mask, set ? caps_lock_mask : 0);
+        }
+        return;
+    case X11_NUM_LOCK_LED:
+        if (num_lock_mask) {
+            XkbLockModifiers(x_display, XkbUseCoreKbd, num_lock_mask, set ? num_lock_mask : 0);
+        }
+        return;
+    case X11_SCROLL_LOCK_LED:
+        XKeyboardControl keyboard_control;
+        keyboard_control.led_mode = set ? LedModeOn : LedModeOff;
+        keyboard_control.led = led;
+        XChangeKeyboardControl(x_display, KBLed | KBLedMode, &keyboard_control);
+        return;
+    }
+}
+
+void Platform::set_keyboard_modifiers(uint32_t modifiers)
+{
+    uint32_t now = get_keyboard_modifiers();
+
+    if ((now & CAPS_LOCK_MODIFIER) != (modifiers & CAPS_LOCK_MODIFIER)) {
+        set_keyboard_led(X11_CAPS_LOCK_LED, !!(modifiers & CAPS_LOCK_MODIFIER));
+    }
+    if ((now & NUM_LOCK_MODIFIER) != (modifiers & NUM_LOCK_MODIFIER)) {
+        set_keyboard_led(X11_NUM_LOCK_LED, !!(modifiers & NUM_LOCK_MODIFIER));
+    }
+    if ((now & SCROLL_LOCK_MODIFIER) != (modifiers & SCROLL_LOCK_MODIFIER)) {
+        set_keyboard_led(X11_SCROLL_LOCK_LED, !!(modifiers & SCROLL_LOCK_MODIFIER));
+    }
+}
+
+WaveRecordAbstract* Platform::create_recorder(RecordClinet& client,
+                                              uint32_t sampels_per_sec,
+                                              uint32_t bits_per_sample,
+                                              uint32_t channels)
+{
+    return new WaveRecorder(client, sampels_per_sec, bits_per_sample, channels);
+}
+
+WavePlaybackAbstract* Platform::create_player(uint32_t sampels_per_sec,
+                                              uint32_t bits_per_sample,
+                                              uint32_t channels)
+{
+    return new WavePlayer(sampels_per_sec, bits_per_sample, channels);
+}
+
+void XPlatform::on_focus_in()
+{
+    if (focus_count++ == 0) {
+        event_listener->on_app_activated();
+    }
+}
+
+void XPlatform::on_focus_out()
+{
+    ASSERT(focus_count > 0);
+    if (--focus_count == 0) {
+        event_listener->on_app_deactivated();
+    }
+}
+
+class XBaseLocalCursor: public LocalCursor {
+public:
+    XBaseLocalCursor() : _handle (0) {}
+    ~XBaseLocalCursor();
+    void set(Window window);
+
+protected:
+    Cursor _handle;
+};
+
+void XBaseLocalCursor::set(Window window)
+{
+    if (_handle) {
+        XDefineCursor(x_display, window, _handle);
+    }
+}
+
+XBaseLocalCursor::~XBaseLocalCursor()
+{
+    if (_handle) {
+        XFreeCursor(x_display, _handle);
+    }
+}
+
+class XLocalCursor: public XBaseLocalCursor {
+public:
+    XLocalCursor(CursorData* cursor_data);
+};
+
+static inline uint8_t get_pix_mask(const uint8_t* data, int offset, int pix_index)
+{
+    return data[offset + (pix_index >> 3)] & (0x80 >> (pix_index % 8));
+}
+
+static inline uint32_t get_pix_hack(int pix_index, int width)
+{
+    return (((pix_index % width) ^ (pix_index / width)) & 1) ? 0xc0303030 : 0x30505050;
+}
+
+XLocalCursor::XLocalCursor(CursorData* cursor_data)
+{
+    const CursorHeader& header = cursor_data->header();
+    const uint8_t* data = cursor_data->data();
+    int cur_size = header.width * header.height;
+    uint8_t pix_mask;
+    uint32_t pix;
+    uint16_t i;
+    int size;
+
+    if (!get_size_bits(header, size)) {
+        THROW("invalid curosr type");
+    }
+
+    uint32_t* cur_data = new uint32_t[cur_size];
+
+    switch (header.type) {
+    case CURSOR_TYPE_ALPHA:
+        break;
+    case CURSOR_TYPE_COLOR32:
+        memcpy(cur_data, data, cur_size * sizeof(uint32_t));
+        for (i = 0; i < cur_size; i++) {
+            pix_mask = get_pix_mask(data, size, i);
+            if (pix_mask && *((uint32_t*)data + i) == 0xffffff) {
+                cur_data[i] = get_pix_hack(i, header.width);
+            } else {
+                cur_data[i] |= (pix_mask ? 0 : 0xff000000);
+            }
+        }
+        break;
+    case CURSOR_TYPE_COLOR16:
+        for (i = 0; i < cur_size; i++) {
+            pix_mask = get_pix_mask(data, size, i);
+            pix = *((uint16_t*)data + i);
+            if (pix_mask && pix == 0x7fff) {
+                cur_data[i] = get_pix_hack(i, header.width);
+            } else {
+                cur_data[i] = ((pix & 0x1f) << 3) | ((pix & 0x3e0) << 6) | ((pix & 0x7c00) << 9) |
+                    (pix_mask ? 0 : 0xff000000);
+            }
+        }
+        break;
+    case CURSOR_TYPE_MONO:
+        for (i = 0; i < cur_size; i++) {
+            pix_mask = get_pix_mask(data, 0, i);
+            pix = get_pix_mask(data, size, i);
+            if (pix_mask && pix) {
+                cur_data[i] = get_pix_hack(i, header.width);
+            } else {
+                cur_data[i] = (pix ? 0xffffff : 0) | (pix_mask ? 0 : 0xff000000);
+            }
+        }
+        break;
+    case CURSOR_TYPE_COLOR4:
+        for (i = 0; i < cur_size; i++) {
+            pix_mask = get_pix_mask(data, size + (sizeof(uint32_t) << 4), i);
+            int idx = (i & 1) ? (data[i >> 1] & 0x0f) : ((data[i >> 1] & 0xf0) >> 4);
+            pix = *((uint32_t*)(data + size) + idx);
+            if (pix_mask && pix == 0xffffff) {
+                cur_data[i] = get_pix_hack(i, header.width);
+            } else {
+                cur_data[i] = pix | (pix_mask ? 0 : 0xff000000);
+            }
+        }
+        break;
+    case CURSOR_TYPE_COLOR24:
+    case CURSOR_TYPE_COLOR8:
+    default:
+        LOG_WARN("unsupported cursor type %d", header.type);
+        _handle = XCreateFontCursor(x_display, XC_arrow);
+        delete[] cur_data;
+        return;
+    }
+
+    XImage image;
+    memset(&image, 0, sizeof(image));
+    image.width = header.width;
+    image.height = header.height;
+    image.data = (header.type == CURSOR_TYPE_ALPHA ? (char*)data : (char*)cur_data);
+    image.byte_order = LSBFirst;
+    image.bitmap_unit = 32;
+    image.bitmap_bit_order = LSBFirst;
+    image.bitmap_pad = 8;
+    image.bytes_per_line = header.width << 2;
+    image.depth = 32;
+    image.format = ZPixmap;
+    image.bits_per_pixel = 32;
+    image.red_mask = 0x00ff0000;
+    image.green_mask = 0x0000ff00;
+    image.blue_mask = 0x000000ff;
+    if (!XInitImage(&image)) {
+        THROW("init image failed");
+    }
+
+    Window root_window = RootWindow(x_display, DefaultScreen(x_display));
+    Pixmap pixmap = XCreatePixmap(x_display, root_window, header.width, header.height, 32);
+
+    XGCValues gc_vals;
+    gc_vals.function = GXcopy;
+    gc_vals.foreground = ~0;
+    gc_vals.background = 0;
+    gc_vals.plane_mask = AllPlanes;
+
+    GC gc = XCreateGC(x_display, pixmap, GCFunction | GCForeground | GCBackground | GCPlaneMask,
+                      &gc_vals);
+    XPutImage(x_display, pixmap, gc, &image, 0, 0, 0, 0, header.width, header.height);
+    XFreeGC(x_display, gc);
+
+    XRenderPictFormat *xformat = XRenderFindStandardFormat(x_display, PictStandardARGB32);
+    Picture picture = XRenderCreatePicture(x_display, pixmap, xformat, 0, NULL);
+    _handle = XRenderCreateCursor(x_display, picture, header.hot_spot_x, header.hot_spot_y);
+    XRenderFreePicture(x_display, picture);
+    XFreePixmap(x_display, pixmap);
+    delete[] cur_data;
+}
+
+LocalCursor* Platform::create_local_cursor(CursorData* cursor_data)
+{
+    ASSERT(using_xrender_0_5);
+    return new XLocalCursor(cursor_data);
+}
+
+class XInactiveCursor: public XBaseLocalCursor {
+public:
+    XInactiveCursor() { _handle = XCreateFontCursor(x_display, XC_X_cursor);}
+};
+
+LocalCursor* Platform::create_inactive_cursor()
+{
+    return new XInactiveCursor();
+}
+
+class XDefaultCursor: public XBaseLocalCursor {
+public:
+    XDefaultCursor() { _handle = XCreateFontCursor(x_display, XC_top_left_arrow);}
+};
+
+LocalCursor* Platform::create_default_cursor()
+{
+    return new XDefaultCursor();
+}
+
diff --git a/client/x11/platform_utils.cpp b/client/x11/platform_utils.cpp
new file mode 100644
index 00000000..e7f6de38
--- /dev/null
+++ b/client/x11/platform_utils.cpp
@@ -0,0 +1,48 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdarg.h>
+#include "utils.h"
+
+void string_vprintf(std::string& str, const char* format, va_list ap)
+{
+    va_list ap_test;
+    va_copy(ap_test, ap);
+    int len = vsnprintf(NULL, 0, format, ap_test) + 1;
+    va_end(ap_test);
+    AutoArray<char> buf(new char[len]);
+    vsnprintf(buf.get(), len, format, ap);
+    str = buf.get();
+}
+
+void wstring_vprintf(std::wstring& str, const wchar_t* format, va_list ap)
+{
+    int buf_size = 256;
+    for (;;) {
+        AutoArray<wchar_t> buf(new wchar_t[buf_size]);
+        va_list ap_test;
+        va_copy(ap_test, ap);
+        int r = vswprintf(buf.get(), buf_size, format, ap_test);
+        va_end(ap_test);
+        if (r != -1) {
+            str = buf.get();
+            return;
+        }
+        buf_size *= 2;
+    }
+}
+
diff --git a/client/x11/platform_utils.h b/client/x11/platform_utils.h
new file mode 100644
index 00000000..763a70e5
--- /dev/null
+++ b/client/x11/platform_utils.h
@@ -0,0 +1,28 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_PLATFORM_UTILS
+#define _H_PLATFORM_UTILS
+
+#ifdef __i386__
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : : "memory")
+#else
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%rsp)": : : "memory")
+#endif
+
+#endif
+
diff --git a/client/x11/playback.cpp b/client/x11/playback.cpp
new file mode 100644
index 00000000..d8f97669
--- /dev/null
+++ b/client/x11/playback.cpp
@@ -0,0 +1,215 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "playback.h"
+#include "utils.h"
+#include "debug.h"
+
+WavePlayer::WavePlayer(uint32_t sampels_per_sec, uint32_t bits_per_sample, uint32_t channels)
+    : _pcm (NULL)
+    , _hw_params (NULL)
+    , _sw_params (NULL)
+{
+    if (!init(sampels_per_sec, bits_per_sample, channels)) {
+        cleanup();
+        THROW("failed");
+    }
+}
+
+void WavePlayer::cleanup()
+{
+    if (_pcm) {
+        snd_pcm_close(_pcm);
+    }
+
+    if (_hw_params) {
+        snd_pcm_hw_params_free(_hw_params);
+    }
+
+    if (_sw_params) {
+        snd_pcm_sw_params_free(_sw_params);
+    }
+}
+
+WavePlayer::~WavePlayer()
+{
+    cleanup();
+}
+
+bool WavePlayer::init(uint32_t sampels_per_sec,
+                      uint32_t bits_per_sample,
+                      uint32_t channels)
+{
+    const int frame_size = WavePlaybackAbstract::FRAME_SIZE;
+    const char* pcm_device = "default";
+    snd_pcm_format_t format;
+    int err;
+
+    switch (bits_per_sample) {
+    case 8:
+        format = SND_PCM_FORMAT_S8;
+        break;
+    case 16:
+        format = SND_PCM_FORMAT_S16_LE;
+        break;
+    default:
+        return false;
+    }
+    _sampels_per_ms = sampels_per_sec / 1000;
+
+    if ((err = snd_pcm_open(&_pcm, pcm_device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) < 0) {
+        LOG_ERROR("cannot open audio playback device %s %s", pcm_device, snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_malloc(&_hw_params)) < 0) {
+        LOG_ERROR("cannot allocate hardware parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params_malloc(&_sw_params)) < 0) {
+        LOG_ERROR("cannot allocate software parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_any(_pcm, _hw_params)) < 0) {
+        LOG_ERROR("cannot initialize hardware parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_rate_resample(_pcm, _hw_params, 1)) < 0) {
+        LOG_ERROR("cannot set rate resample %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_access(_pcm, _hw_params,
+                                            SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
+        LOG_ERROR("cannot set access type %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_rate(_pcm, _hw_params, sampels_per_sec, 0)) < 0) {
+        LOG_ERROR("cannot set sample rate %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_channels(_pcm, _hw_params, channels)) < 0) {
+        LOG_ERROR("cannot set channel count %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_format(_pcm, _hw_params, format)) < 0) {
+        LOG_ERROR("cannot set sample format %s", snd_strerror(err));
+        return false;
+    }
+
+    snd_pcm_uframes_t buffer_size = (sampels_per_sec * 80 / 1000) / frame_size * frame_size;
+
+    if ((err = snd_pcm_hw_params_set_buffer_size_near(_pcm, _hw_params, &buffer_size)) < 0) {
+        LOG_ERROR("cannot set buffer size %s", snd_strerror(err));
+        return false;
+    }
+
+    int direction = 1;
+    snd_pcm_uframes_t period_size = (sampels_per_sec * 20 / 1000) / frame_size * frame_size;
+    if ((err = snd_pcm_hw_params_set_period_size_near(_pcm, _hw_params, &period_size,
+                                                      &direction)) < 0) {
+        LOG_ERROR("cannot set period size %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params(_pcm, _hw_params)) < 0) {
+        LOG_ERROR("cannot set parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params_current(_pcm, _sw_params)) < 0) {
+        LOG_ERROR("cannot obtain sw parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    err = snd_pcm_hw_params_get_buffer_size(_hw_params, &buffer_size);
+    if (err < 0) {
+        LOG_ERROR("unable to get buffer size for playback: %s", snd_strerror(err));
+        return false;
+    }
+
+    direction = 0;
+    err = snd_pcm_hw_params_get_period_size(_hw_params, &period_size, &direction);
+    if (err < 0) {
+        LOG_ERROR("unable to get period size for playback: %s", snd_strerror(err));
+        return false;
+    }
+
+    err = snd_pcm_sw_params_set_start_threshold(_pcm, _sw_params,
+                                                (buffer_size / period_size) * period_size);
+    if (err < 0) {
+        LOG_ERROR("unable to set start threshold mode for playback: %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params(_pcm, _sw_params)) < 0) {
+        LOG_ERROR("cannot set software parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_prepare(_pcm)) < 0) {
+        LOG_ERROR("cannot prepare pcm device %s", snd_strerror(err));
+        return false;
+    }
+
+    return true;
+}
+
+bool WavePlayer::write(uint8_t* frame)
+{
+    snd_pcm_sframes_t ret = snd_pcm_writei(_pcm, frame, WavePlaybackAbstract::FRAME_SIZE);
+    if (ret < 0) {
+        if (ret == -EAGAIN) {
+            return false;
+        }
+        DBG(0, "err %s", snd_strerror(-ret));
+        if (snd_pcm_recover(_pcm, ret, 1) == 0) {
+            snd_pcm_writei(_pcm, frame, WavePlaybackAbstract::FRAME_SIZE);
+        }
+    }
+    return true;
+}
+
+void WavePlayer::stop()
+{
+    snd_pcm_drain(_pcm);
+    snd_pcm_prepare(_pcm);
+}
+
+bool WavePlayer::abort()
+{
+    return true;
+}
+
+uint32_t WavePlayer::get_delay_ms()
+{
+    ASSERT(_pcm);
+
+    snd_pcm_sframes_t delay;
+
+    if (snd_pcm_delay(_pcm, &delay) < 0) {
+        return 0;
+    }
+    return delay / _sampels_per_ms;
+}
+
diff --git a/client/x11/playback.h b/client/x11/playback.h
new file mode 100644
index 00000000..151f5afc
--- /dev/null
+++ b/client/x11/playback.h
@@ -0,0 +1,48 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_LINUX_PLAYBACK
+#define _H_LINUX_PLAYBACK
+
+#include <alsa/asoundlib.h>
+
+#include "common.h"
+#include "audio_devices.h"
+
+class WavePlayer: public WavePlaybackAbstract {
+public:
+    WavePlayer(uint32_t sampels_per_sec, uint32_t bits_per_sample, uint32_t channels);
+    virtual ~WavePlayer();
+
+    virtual bool write(uint8_t* frame);
+    virtual bool abort();
+    virtual void stop();
+    virtual uint32_t get_delay_ms();
+
+private:
+    bool init(uint32_t sampels_per_sec, uint32_t bits_per_sample, uint32_t channel);
+    void cleanup();
+
+private:
+    snd_pcm_t* _pcm;
+    snd_pcm_hw_params_t* _hw_params;
+    snd_pcm_sw_params_t* _sw_params;
+    uint32_t _sampels_per_ms;
+};
+
+#endif
+
diff --git a/client/x11/record.cpp b/client/x11/record.cpp
new file mode 100644
index 00000000..b68e2130
--- /dev/null
+++ b/client/x11/record.cpp
@@ -0,0 +1,238 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "record.h"
+#include "utils.h"
+#include "debug.h"
+
+
+class WaveRecorder::EventTrigger: public EventsLoop::File {
+public:
+    EventTrigger(WaveRecorder& recorder, int fd);
+    virtual void on_event();
+    virtual int get_fd() { return _fd;}
+
+private:
+    WaveRecorder& _recorder;
+    int _fd;
+};
+
+WaveRecorder::EventTrigger::EventTrigger(WaveRecorder& recorder, int fd)
+    : _recorder (recorder)
+    , _fd (fd)
+{
+}
+
+void WaveRecorder::EventTrigger::on_event()
+{
+    _recorder.on_event();
+}
+
+WaveRecorder::WaveRecorder(Platform::RecordClinet& client,
+                           uint32_t sampels_per_sec,
+                           uint32_t bits_per_sample,
+                           uint32_t channels)
+    : _client (client)
+    , _pcm (NULL)
+    , _hw_params (NULL)
+    , _sw_params (NULL)
+    , _sample_bytes (bits_per_sample * channels / 8)
+    , _frame (new uint8_t[_sample_bytes * WaveRecordAbstract::FRAME_SIZE])
+    , _frame_pos (_frame)
+    , _frame_end (_frame + _sample_bytes * WaveRecordAbstract::FRAME_SIZE)
+    , _event_trigger (NULL)
+{
+    if (!init(sampels_per_sec, bits_per_sample, channels)) {
+        cleanup();
+        THROW("failed");
+    }
+}
+
+WaveRecorder::~WaveRecorder()
+{
+    cleanup();
+    delete[] _frame;
+}
+
+void WaveRecorder::cleanup()
+{
+    if (_event_trigger) {
+        _client.remove_evnet_sorce(*_event_trigger);
+        delete _event_trigger;
+    }
+
+    if (_sw_params) {
+        snd_pcm_sw_params_free(_sw_params);
+    }
+
+    if (_hw_params) {
+        snd_pcm_hw_params_free(_hw_params);
+    }
+
+    if (_pcm) {
+        snd_pcm_close(_pcm);
+    }
+}
+
+bool WaveRecorder::init(uint32_t sampels_per_sec,
+                        uint32_t bits_per_sample,
+                        uint32_t channels)
+{
+    const int frame_size = WaveRecordAbstract::FRAME_SIZE;
+    const char* pcm_device = "hw:0,0"; // "default" ???
+    snd_pcm_format_t format;
+    int err;
+
+    switch (bits_per_sample) {
+    case 8:
+        format = SND_PCM_FORMAT_S8;
+        break;
+    case 16:
+        format = SND_PCM_FORMAT_S16_LE;
+        break;
+    default:
+        return false;
+    }
+
+    if ((err = snd_pcm_open(&_pcm, pcm_device, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0) {
+        LOG_ERROR("cannot open audio record device %s %s", pcm_device, snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_malloc(&_hw_params)) < 0) {
+        LOG_ERROR("cannot allocate hardware parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params_malloc(&_sw_params)) < 0) {
+        LOG_ERROR("cannot allocate software parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_any(_pcm, _hw_params)) < 0) {
+        LOG_ERROR("cannot initialize hardware parameter structure %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_rate_resample(_pcm, _hw_params, 1)) < 0) {
+        LOG_ERROR("cannot set rate resample %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_access(_pcm, _hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
+        LOG_ERROR("cannot set access type %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_rate(_pcm, _hw_params, sampels_per_sec, 0)) < 0) {
+        LOG_ERROR("cannot set sample rate %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_channels(_pcm, _hw_params, channels)) < 0) {
+        LOG_ERROR("cannot set channel count %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params_set_format(_pcm, _hw_params, format)) < 0) {
+        LOG_ERROR("cannot set sample format %s", snd_strerror(err));
+        return false;
+    }
+
+    int direction = 0;
+    snd_pcm_uframes_t buffer_size = (sampels_per_sec * 160 / 1000) / frame_size * frame_size;
+
+    if ((err = snd_pcm_hw_params_set_buffer_size_near(_pcm, _hw_params, &buffer_size)) < 0) {
+        LOG_ERROR("cannot set buffer size %s", snd_strerror(err));
+        return false;
+    }
+
+    snd_pcm_uframes_t period_size = frame_size;
+    if ((err = snd_pcm_hw_params_set_period_size_near(_pcm, _hw_params, &period_size,
+                                                      &direction)) < 0) {
+        LOG_ERROR("cannot set period size near %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_hw_params(_pcm, _hw_params)) < 0) {
+        LOG_ERROR("cannot set parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params_current(_pcm, _sw_params)) < 0) {
+        LOG_ERROR("cannot get current sw parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params_set_start_threshold(_pcm, _sw_params, frame_size)) < 0) {
+        LOG_ERROR("cannot set start treshold %s", snd_strerror(err));
+        return false;
+    }
+
+    if ((err = snd_pcm_sw_params(_pcm, _sw_params)) < 0) {
+        LOG_ERROR("cannot set sw parameters %s", snd_strerror(err));
+        return false;
+    }
+
+    struct pollfd pfd;
+    if ((err = snd_pcm_poll_descriptors(_pcm, &pfd, 1)) < 0) {
+        LOG_ERROR("cannot get poll ID %s", snd_strerror(err));
+        return false;
+    }
+    _event_trigger = new WaveRecorder::EventTrigger(*this, pfd.fd);
+    _client.add_evnet_sorce(*_event_trigger);
+    return true;
+}
+
+void WaveRecorder::start()
+{
+    _frame_pos = _frame;
+    snd_pcm_prepare(_pcm);
+    snd_pcm_start(_pcm);
+    snd_pcm_nonblock(_pcm, 1);
+}
+
+void WaveRecorder::stop()
+{
+    snd_pcm_drop(_pcm);
+    snd_pcm_prepare(_pcm);
+}
+
+bool WaveRecorder::abort()
+{
+    return true;
+}
+
+void WaveRecorder::on_event()
+{
+    for (;;) {
+        snd_pcm_sframes_t size = (_frame_end - _frame_pos) / _sample_bytes;
+        size = snd_pcm_readi(_pcm, _frame_pos, size);
+        if (size < 0) {
+            if (snd_pcm_recover(_pcm, size, 1) == 0) {
+                continue;
+            }
+            return;
+        }
+        _frame_pos += size * _sample_bytes;
+        if (_frame_pos == _frame_end) {
+            _client.push_frame(_frame);
+            _frame_pos = _frame;
+        }
+    }
+}
+
diff --git a/client/x11/record.h b/client/x11/record.h
new file mode 100644
index 00000000..540f1d2f
--- /dev/null
+++ b/client/x11/record.h
@@ -0,0 +1,60 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_LINUX_RECORD
+#define _H_LINUX_RECORD
+
+#include <alsa/asoundlib.h>
+
+#include "common.h"
+#include "audio_devices.h"
+#include "platform.h"
+
+class WaveRecorder: public WaveRecordAbstract {
+public:
+    WaveRecorder(Platform::RecordClinet& client,
+                 uint32_t sampels_per_sec,
+                 uint32_t bits_per_sample,
+                 uint32_t channels);
+    virtual ~WaveRecorder();
+
+    virtual void start();
+    virtual void stop();
+    virtual bool abort();
+
+private:
+    bool init(uint32_t sampels_per_sec,
+              uint32_t bits_per_sample,
+              uint32_t channels);
+    void cleanup();
+    void on_event();
+
+private:
+    Platform::RecordClinet& _client;
+    snd_pcm_t* _pcm;
+    snd_pcm_hw_params_t* _hw_params;
+    snd_pcm_sw_params_t* _sw_params;
+    uint32_t _sample_bytes;
+    uint8_t* _frame;
+    uint8_t* _frame_pos;
+    uint8_t* _frame_end;
+    class EventTrigger;
+    EventTrigger* _event_trigger;
+};
+
+#endif
+
diff --git a/client/x11/red_drawable.cpp b/client/x11/red_drawable.cpp
new file mode 100644
index 00000000..4436152b
--- /dev/null
+++ b/client/x11/red_drawable.cpp
@@ -0,0 +1,699 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+#include "common.h"
+#include "red_drawable.h"
+#include "pixels_source_p.h"
+#include "debug.h"
+#include "x_platform.h"
+#include "utils.h"
+#include "gl_utils.h"
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glext.h>
+
+static inline void copy_to_gldrawable_from_gltexture(const RedDrawable_p* dest,
+                                                     const Rect& area,
+                                                     const Point& offset,
+                                                     const PixelsSource_p* source,
+                                                     int src_x, int src_y)
+{
+    float text_x1, text_x2;
+    float text_y1, text_y2;
+    int vertex_x1, vertex_x2;
+    int vertex_y1, vertex_y2;
+    GLXPbuffer pbuffer;
+    GLXContext context;
+    RenderType rendertype;
+    Window win;
+
+    text_x1 = (float)src_x / source->gl.width_powed;
+    text_x2 = text_x1 + (float)(area.right - area.left) / source->gl.width_powed;
+
+    text_y1 = ((float)source->gl.height - (area.bottom - area.top) - src_y) /
+              source->gl.height_powed;
+    text_y2 = text_y1 + (float)(area.bottom - area.top) / source->gl.height_powed;
+
+    vertex_x1 = area.left + offset.x;
+    vertex_y1 = dest->source.x_drawable.height - (area.top + offset.y) - (area.bottom - area.top);
+    vertex_x2 = vertex_x1 + (area.right - area.left);
+    vertex_y2 = vertex_y1 + (area.bottom - area.top);
+
+    glEnable(GL_TEXTURE_2D);
+
+    rendertype = source->gl.rendertype;
+    if (rendertype == RENDER_TYPE_FBO) {
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    } else {
+        win = source->gl.win;
+        context = source->gl.context;
+        glXMakeCurrent(XPlatform::get_display(), win, context);
+    }
+
+    glBindTexture(GL_TEXTURE_2D, source->gl.tex);
+
+    glBegin(GL_QUADS);
+    glTexCoord2f(text_x1, text_y1);
+    glVertex2i(vertex_x1, vertex_y1);
+    glTexCoord2f(text_x1, text_y2);
+    glVertex2i(vertex_x1, vertex_y2);
+    glTexCoord2f(text_x2, text_y2);
+    glVertex2i(vertex_x2, vertex_y2);
+    glTexCoord2f(text_x2, text_y1);
+    glVertex2i(vertex_x2, vertex_y1);
+    glEnd();
+
+    if (rendertype == RENDER_TYPE_FBO) {
+        GLuint fbo;
+
+        fbo = source->gl.fbo;
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+    } else {
+        pbuffer = source->gl.pbuff;
+        glXMakeCurrent(XPlatform::get_display(), pbuffer, context);
+    }
+}
+
+static inline void copy_to_gldrawable_from_pixmap(const RedDrawable_p* dest,
+                                                  const Rect& area,
+                                                  const Point& offset,
+                                                  const PixelsSource_p* source,
+                                                  int src_x, int src_y)
+{
+    uint8_t *addr;
+    GLXContext context = NULL;
+    GLXPbuffer pbuffer;
+    RenderType rendertype;
+    Window win;
+
+    rendertype = dest->source.x_drawable.rendertype;
+    if (rendertype == RENDER_TYPE_FBO) {
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+        glBindTexture(GL_TEXTURE_2D, 0);
+    } else {
+        context = dest->source.x_drawable.context;
+        win = dest->source.x_drawable.drawable;
+        glXMakeCurrent(XPlatform::get_display(), win, context);
+        glDisable(GL_TEXTURE_2D);
+    }
+
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, source->pixmap.x_image->bytes_per_line / 4);
+
+    glPixelZoom(1, -1);
+    addr = (uint8_t *)source->pixmap.x_image->data;
+    addr += (src_x * 4 + src_y * source->pixmap.x_image->bytes_per_line);
+    glWindowPos2i(area.left + offset.x, dest->source.x_drawable.height -
+                  (area.top + offset.y));  //+ (area.bottom - area.top)));
+    glDrawPixels(area.right - area.left, area.bottom - area.top,
+                 GL_BGRA, GL_UNSIGNED_BYTE, addr);
+
+    if (rendertype == RENDER_TYPE_FBO) {
+        GLuint fbo;
+
+        fbo = dest->source.x_drawable.fbo;
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+    } else {
+        pbuffer = dest->source.x_drawable.pbuff;
+        glXMakeCurrent(XPlatform::get_display(), pbuffer, context);
+    }
+}
+
+static inline void copy_to_drawable_from_drawable(const RedDrawable_p* dest,
+                                                  const Rect& area,
+                                                  const Point& offset,
+                                                  const PixelsSource_p* source,
+                                                  int src_x, int src_y)
+{
+    XGCValues gc_vals;
+    gc_vals.function = GXcopy;
+
+    XChangeGC(XPlatform::get_display(), dest->source.x_drawable.gc, GCFunction, &gc_vals);
+    XCopyArea(XPlatform::get_display(), source->x_drawable.drawable,
+              dest->source.x_drawable.drawable, dest->source.x_drawable.gc,
+              src_x, src_y,
+              area.right - area.left, area.bottom - area.top,
+              area.left + offset.x, area.top + offset.y);
+}
+
+static inline void copy_to_drawable_from_pixmap(const RedDrawable_p* dest,
+                                                const Rect& area,
+                                                const Point& offset,
+                                                const PixelsSource_p* source,
+                                                int src_x, int src_y)
+{
+    XGCValues gc_vals;
+    gc_vals.function = GXcopy;
+
+    XChangeGC(XPlatform::get_display(), dest->source.x_drawable.gc, GCFunction, &gc_vals);
+    XPutImage(XPlatform::get_display(), dest->source.x_drawable.drawable,
+              dest->source.x_drawable.gc, source->pixmap.x_image, src_x,
+              src_y, area.left + offset.x, area.top + offset.y,
+              area.right - area.left, area.bottom - area.top);
+}
+
+static inline void copy_to_drawable_from_shmdrawable(const RedDrawable_p* dest,
+                                                     const Rect& area,
+                                                     const Point& offset,
+                                                     const PixelsSource_p* source,
+                                                     int src_x, int src_y)
+{
+    XGCValues gc_vals;
+    gc_vals.function = GXcopy;
+
+    XChangeGC(XPlatform::get_display(), dest->source.x_drawable.gc, GCFunction, &gc_vals);
+    XShmPutImage(XPlatform::get_display(), dest->source.x_drawable.drawable,
+                 dest->source.x_drawable.gc, source->x_shm_drawable.x_image,
+                 src_x, src_y, area.left + offset.x, area.top + offset.y,
+                 area.right - area.left, area.bottom - area.top, false);
+    XSync(XPlatform::get_display(), 0);
+}
+
+static inline void copy_to_x_drawable(const RedDrawable_p* dest,
+                                      const Rect& area,
+                                      const Point& offset,
+                                      const PixelsSource_p* source,
+                                      int src_x, int src_y)
+{
+    switch (source->type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        copy_to_drawable_from_drawable(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        copy_to_drawable_from_pixmap(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_XSHM_DRAWABLE:
+        copy_to_drawable_from_shmdrawable(dest, area, offset, source, src_x, src_y);
+        break;
+    default:
+        THROW("invalid source type %d", source->type);
+    }
+}
+
+static inline void copy_to_gl_drawable(const RedDrawable_p* dest,
+                                       const Rect& area,
+                                       const Point& offset,
+                                       const PixelsSource_p* source,
+                                       int src_x, int src_y)
+{
+    switch (source->type) {
+    case PIXELS_SOURCE_TYPE_GL_TEXTURE:
+        copy_to_gldrawable_from_gltexture(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        copy_to_gldrawable_from_pixmap(dest, area, offset, source, src_x, src_y);
+        break;
+    default:
+        THROW("invalid source type %d", source->type);
+    }
+}
+
+static inline void copy_to_pixmap_from_drawable(const RedDrawable_p* dest,
+                                                const Rect& area,
+                                                const Point& offset,
+                                                const PixelsSource_p* source,
+                                                int src_x, int src_y)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void copy_to_pixmap_from_shmdrawable(const RedDrawable_p* dest,
+                                                   const Rect& area,
+                                                   const Point& offset,
+                                                   const PixelsSource_p* source,
+                                                   int src_x, int src_y)
+{
+    cairo_t* cairo = dest->cairo;
+    cairo_surface_t* surf = source->x_shm_drawable.cairo_surf;
+
+    ASSERT(cairo);
+    ASSERT(surf);
+
+    cairo_set_source_surface(cairo, surf, area.left + offset.x - src_x,
+                             area.top + offset.y - src_y);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                    area.bottom - area.top);
+    cairo_fill(cairo);
+}
+
+static inline void copy_to_pixmap_from_pixmap(const RedDrawable_p* dest,
+                                              const Rect& area,
+                                              const Point& offset,
+                                              const PixelsSource_p* source,
+                                              int src_x, int src_y)
+{
+    cairo_t* cairo = dest->cairo;
+    cairo_surface_t* surf = source->pixmap.cairo_surf;
+
+    ASSERT(cairo);
+    ASSERT(surf);
+
+    cairo_set_source_surface(cairo, surf, area.left + offset.x - src_x,
+                             area.top + offset.y - src_y);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                    area.bottom - area.top);
+    cairo_fill(cairo);
+}
+
+static inline void copy_to_pixmap_from_gltexture(const RedDrawable_p* dest,
+                                                 const Rect& area,
+                                                 const Point& offset,
+                                                 const PixelsSource_p* source,
+                                                 int src_x, int src_y)
+{
+    int y, height;
+    GLXContext context = NULL;
+    GLXPbuffer pbuffer;
+    Window win;
+    RenderType rendertype;
+
+    y = source->gl.height - src_y;
+    height = area.bottom - area.top;
+
+    rendertype = source->gl.rendertype;
+    if (rendertype == RENDER_TYPE_FBO) {
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, source->gl.fbo);
+        glBindTexture(GL_TEXTURE_2D, 0);
+    } else {
+        context = source->gl.context;
+        pbuffer = source->gl.pbuff;
+        glXMakeCurrent(XPlatform::get_display(), pbuffer, context);
+        glDisable(GL_TEXTURE_2D);
+    }
+    glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
+    glPixelStorei(GL_PACK_ROW_LENGTH,
+                  dest->source.pixmap.x_image->bytes_per_line / 4);
+
+    while (height > 0) {
+        glReadPixels(src_x, y - height, area.right - area.left, 1,
+                     GL_BGRA, GL_UNSIGNED_BYTE,
+                     dest->source.pixmap.x_image->data +
+                     (area.left + offset.x) * 4 +
+                     (area.top + offset.y + height - 1) *
+                     dest->source.pixmap.x_image->bytes_per_line);
+        height--;
+    }
+    if (rendertype != RENDER_TYPE_FBO) {
+        win = source->gl.win;
+        glXMakeCurrent(XPlatform::get_display(), win, context);
+    }
+}
+
+static inline void copy_to_pixmap(const RedDrawable_p* dest,
+                                  const Rect& area,
+                                  const Point& offset,
+                                  const PixelsSource_p* source,
+                                  int src_x, int src_y)
+{
+    switch (source->type) {
+    case PIXELS_SOURCE_TYPE_GL_TEXTURE:
+        copy_to_pixmap_from_gltexture(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        copy_to_pixmap_from_drawable(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        copy_to_pixmap_from_pixmap(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_XSHM_DRAWABLE:
+        copy_to_pixmap_from_shmdrawable(dest, area, offset, source, src_x, src_y);
+        break;
+    default:
+        THROW("invalid source type %d", source->type);
+    }
+}
+
+void RedDrawable::copy_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area)
+{
+    PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
+    RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
+    switch (dest->source.type) {
+    case PIXELS_SOURCE_TYPE_GL_DRAWABLE:
+        copy_to_gl_drawable(dest, area, _origin, source, src_x + src._origin.x,
+                            src_y + src._origin.y);
+        break;
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        copy_to_x_drawable(dest, area, _origin, source, src_x + src._origin.x,
+                           src_y + src._origin.y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        copy_to_pixmap(dest, area, _origin, source, src_x + src._origin.x, src_y + src._origin.y);
+        break;
+    default:
+        THROW("invalid dest type %d", dest->source.type);
+    }
+}
+
+static inline void blend_to_drawable(const RedDrawable_p* dest,
+                                     const Rect& area,
+                                     const Point& offset,
+                                     const PixelsSource_p* source,
+                                     int src_x, int src_y)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void blend_to_pixmap_from_drawable(const RedDrawable_p* dest,
+                                                 const Rect& area,
+                                                 const Point& offset,
+                                                 const PixelsSource_p* source,
+                                                 int src_x, int src_y)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void blend_to_pixmap_from_pixmap(const RedDrawable_p* dest,
+                                               const Rect& area,
+                                               const Point& offset,
+                                               const PixelsSource_p* source,
+                                               int src_x, int src_y)
+{
+    cairo_t* cairo = dest->cairo;
+    cairo_surface_t* surf = source->pixmap.cairo_surf;
+
+    ASSERT(cairo);
+    ASSERT(surf);
+
+    cairo_set_source_surface(cairo, surf, (area.left + offset.x - src_x),
+                             (area.top + offset.y - src_y));
+    cairo_set_operator(cairo, CAIRO_OPERATOR_ATOP);
+    cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                    area.bottom - area.top);
+    cairo_fill(cairo);
+}
+
+static inline void blend_to_pixmap(const RedDrawable_p* dest,
+                                   const Rect& area,
+                                   const Point& offset,
+                                   const PixelsSource_p* source,
+                                   int src_x, int src_y)
+{
+    switch (source->type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        blend_to_pixmap_from_drawable(dest, area, offset, source, src_x, src_y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        blend_to_pixmap_from_pixmap(dest, area, offset, source, src_x, src_y);
+        break;
+    default:
+        THROW("invalid source type %d", source->type);
+    }
+}
+
+void RedDrawable::blend_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area)
+{
+    PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
+    RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
+    switch (dest->source.type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        blend_to_drawable(dest, area, _origin, source, src_x + src._origin.x,
+                          src_y + src._origin.y);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        blend_to_pixmap(dest, area, _origin, source, src_x + src._origin.x, src_y + src._origin.y);
+        break;
+    default:
+        THROW("invalid dest type %d", dest->source.type);
+    }
+}
+
+static inline void combine_to_drawable(const RedDrawable_p* dest,
+                                       const Rect& area,
+                                       const Point& offset,
+                                       const PixelsSource_p* source,
+                                       int src_x, int src_y,
+                                       RedDrawable::CombineOP op)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void combine_to_pixmap_from_drawable(const RedDrawable_p* dest,
+                                                   const Rect& area,
+                                                   const Point& offset,
+                                                   const PixelsSource_p* source,
+                                                   int src_x, int src_y,
+                                                   RedDrawable::CombineOP op)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void combine_to_pixmap_from_pixmap(const RedDrawable_p* dest,
+                                                 const Rect& area,
+                                                 const Point& offset,
+                                                 const PixelsSource_p* source,
+                                                 int src_x, int src_y,
+                                                 RedDrawable::CombineOP op)
+{
+    cairo_t* cairo = dest->cairo;
+    cairo_surface_t* surf = source->pixmap.cairo_surf;
+
+    ASSERT(cairo);
+    ASSERT(surf);
+    cairo_operator_t cairo_op;
+    switch (op) {
+    case RedDrawable::OP_COPY:
+        cairo_op = CAIRO_OPERATOR_RASTER_COPY;
+        break;
+    case RedDrawable::OP_AND:
+        cairo_op = CAIRO_OPERATOR_RASTER_AND;
+        break;
+    case RedDrawable::OP_XOR:
+        cairo_op = CAIRO_OPERATOR_RASTER_XOR;
+        break;
+    default:
+        THROW("invalid op %d", op);
+    }
+
+
+    cairo_set_operator(cairo, cairo_op);
+    if (cairo_image_surface_get_format(surf) == CAIRO_FORMAT_A1) {
+        cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                        area.bottom - area.top);
+        cairo_clip(cairo);
+        cairo_set_source_rgb(cairo, 1, 1, 1);
+        cairo_mask_surface(cairo, surf, area.left + offset.x - src_x, area.top + offset.y - src_y);
+        cairo_reset_clip(cairo);
+    } else {
+        cairo_set_source_surface(cairo, surf, area.left + offset.x - src_x,
+                                 area.top + offset.y - src_y);
+        cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                        area.bottom - area.top);
+        cairo_fill(cairo);
+    }
+}
+
+static inline void combine_to_pixmap(const RedDrawable_p* dest,
+                                     const Rect& area,
+                                     const Point& offset,
+                                     const PixelsSource_p* source,
+                                     int src_x, int src_y,
+                                     RedDrawable::CombineOP op)
+{
+    switch (source->type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        combine_to_pixmap_from_drawable(dest, area, offset, source, src_x, src_y, op);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        combine_to_pixmap_from_pixmap(dest, area, offset, source, src_x, src_y, op);
+        break;
+    default:
+        THROW("invalid source type %d", source->type);
+    }
+}
+
+void RedDrawable::combine_pixels(const PixelsSource& src, int src_x, int src_y, const Rect& area,
+                                 CombineOP op)
+{
+    PixelsSource_p* source = (PixelsSource_p*)src.get_opaque();
+    RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
+    switch (dest->source.type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        combine_to_drawable(dest, area, _origin, source, src_x + src._origin.x,
+                            src_y + src._origin.y, op);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        combine_to_pixmap(dest, area, _origin, source, src_x + src._origin.x,
+                          src_y + src._origin.y, op);
+        break;
+    default:
+        THROW("invalid dest type %d", dest->source.type);
+    }
+}
+
+void RedDrawable::erase_rect(const Rect& area, rgb32_t color)
+{
+    LOG_WARN("not implemented");
+}
+
+static inline void fill_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
+                                 const Point& offset)
+{
+    Drawable drawable = dest->source.x_drawable.drawable;
+    GC gc = dest->source.x_drawable.gc;
+
+    Colormap color_map = DefaultColormap(XPlatform::get_display(),
+                                         DefaultScreen(XPlatform::get_display()));
+    XColor x_color;
+    x_color.red = (uint16_t)rgb32_get_red(color) << 8;
+    x_color.green = (uint16_t)rgb32_get_green(color) << 8;
+    x_color.blue = (uint16_t)rgb32_get_blue(color) << 8;
+    x_color.flags = DoRed | DoGreen | DoBlue;
+    //todo: optimize color map
+    if (!XAllocColor(XPlatform::get_display(), color_map, &x_color)) {
+        LOG_WARN("color map failed");
+    }
+
+    XGCValues gc_vals;
+    gc_vals.foreground = x_color.pixel;
+    gc_vals.function = GXcopy;
+    gc_vals.fill_style = FillSolid;
+    XChangeGC(XPlatform::get_display(), gc, GCFunction | GCForeground | GCFillStyle, &gc_vals);
+    XFillRectangle(XPlatform::get_display(), drawable,
+                   gc, area.left + offset.x, area.top + offset.y,
+                   area.right - area.left, area.bottom - area.top);
+}
+
+static inline void fill_gl_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
+                                    const Point& offset)
+{
+    int vertex_x1, vertex_x2;
+    int vertex_y1, vertex_y2;
+    GLXContext context;
+
+    context = glXGetCurrentContext();
+    if (!context) {
+        return;
+    }
+
+    vertex_x1 = area.left + offset.x;
+    vertex_y1 = dest->source.x_drawable.height - (area.top + offset.y) - (area.bottom - area.top);
+
+    vertex_x2 = vertex_x1 + (area.right - area.left);
+    vertex_y2 = vertex_y1 + (area.bottom - area.top);
+
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+
+    glColor3f(rgb32_get_red(color), rgb32_get_green(color),
+              rgb32_get_blue(color));
+
+    glBegin(GL_QUADS);
+    glVertex2i(vertex_x1, vertex_y1);
+    glVertex2i(vertex_x1, vertex_y2);
+    glVertex2i(vertex_x2, vertex_y2);
+    glVertex2i(vertex_x2, vertex_y1);
+    glEnd();
+    glFlush();
+
+    glColor3f(1, 1, 1);
+}
+
+static inline void fill_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t color,
+                               const Point& offset)
+{
+    cairo_t* cairo = dest->cairo;
+
+    ASSERT(cairo);
+    cairo_set_source_rgb(cairo,
+                         (double)rgb32_get_red(color) / 0xff,
+                         (double)rgb32_get_green(color) / 0xff,
+                         (double)rgb32_get_blue(color) / 0xff);
+    cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                    area.bottom - area.top);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    cairo_fill(cairo);
+}
+
+void RedDrawable::fill_rect(const Rect& area, rgb32_t color)
+{
+    RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
+    switch (dest->source.type) {
+    case PIXELS_SOURCE_TYPE_GL_DRAWABLE:
+        fill_gl_drawable(dest, area, color, _origin);
+        break;
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        fill_drawable(dest, area, color, _origin);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        fill_pixmap(dest, area, color, _origin);
+        break;
+    default:
+        THROW("invalid dest type %d", dest->source.type);
+    }
+}
+
+static inline void frame_drawable(RedDrawable_p* dest, const Rect& area, rgb32_t color,
+                                  const Point& offset)
+{
+    Drawable drawable = dest->source.x_drawable.drawable;
+    GC gc = dest->source.x_drawable.gc;
+
+    Colormap color_map = DefaultColormap(XPlatform::get_display(),
+                                         DefaultScreen(XPlatform::get_display()));
+    XColor x_color;
+    x_color.red = (uint16_t)rgb32_get_red(color) << 8;
+    x_color.green = (uint16_t)rgb32_get_green(color) << 8;
+    x_color.blue = (uint16_t)rgb32_get_blue(color) << 8;
+    x_color.flags = DoRed | DoGreen | DoBlue;
+    //todo: optimize color map
+    if (!XAllocColor(XPlatform::get_display(), color_map, &x_color)) {
+        LOG_WARN("color map failed");
+    }
+
+    XGCValues gc_vals;
+    gc_vals.foreground = x_color.pixel;
+    gc_vals.function = GXcopy;
+    gc_vals.fill_style = FillSolid;
+    XChangeGC(XPlatform::get_display(), gc, GCFunction | GCForeground | GCFillStyle, &gc_vals);
+    XFillRectangle(XPlatform::get_display(), drawable,
+                   gc, area.left + offset.x, area.top + offset.y,
+                   area.right - area.left, area.bottom - area.top);
+}
+
+static inline void frame_pixmap(RedDrawable_p* dest, const Rect& area, rgb32_t color,
+                                const Point& offset)
+{
+    cairo_t* cairo = dest->cairo;
+
+    ASSERT(cairo);
+    cairo_set_source_rgb(cairo,
+                         (double)rgb32_get_red(color) / 0xff,
+                         (double)rgb32_get_green(color) / 0xff,
+                         (double)rgb32_get_blue(color) / 0xff);
+    cairo_rectangle(cairo, area.left + offset.x, area.top + offset.y, area.right - area.left,
+                    area.bottom - area.top);
+    cairo_set_line_width(cairo, 1);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    cairo_stroke(cairo);
+}
+
+void RedDrawable::frame_rect(const Rect& area, rgb32_t color)
+{
+    RedDrawable_p* dest = (RedDrawable_p*)get_opaque();
+    switch (dest->source.type) {
+    case PIXELS_SOURCE_TYPE_X_DRAWABLE:
+        frame_drawable(dest, area, color, _origin);
+        break;
+    case PIXELS_SOURCE_TYPE_PIXMAP:
+        frame_pixmap(dest, area, color, _origin);
+        break;
+    default:
+        THROW("invalid dest type %d", dest->source.type);
+    }
+}
+
diff --git a/client/x11/red_pixmap.cpp b/client/x11/red_pixmap.cpp
new file mode 100644
index 00000000..85a45515
--- /dev/null
+++ b/client/x11/red_pixmap.cpp
@@ -0,0 +1,42 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_pixmap.h"
+#include "debug.h"
+#include "utils.h"
+
+RedPixmap::RedPixmap(int width, int height, RedPixmap::Format format,
+                     bool top_bottom, rgb32_t* pallet)
+    : _format (format)
+    , _width (width)
+    , _height (height)
+    , _stride (ALIGN(width * (_format == RedPixmap::A1 ? 1 : 32), 32) / 8)
+    , _top_bottom (top_bottom)
+    , _data (NULL)
+{
+}
+
+RedPixmap::~RedPixmap()
+{
+}
+
+bool RedPixmap::is_big_endian_bits()
+{
+    return false;
+}
+
diff --git a/client/x11/red_pixmap_cairo.cpp b/client/x11/red_pixmap_cairo.cpp
new file mode 100644
index 00000000..c1454865
--- /dev/null
+++ b/client/x11/red_pixmap_cairo.cpp
@@ -0,0 +1,197 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "red_pixmap_cairo.h"
+#include "debug.h"
+#include "utils.h"
+#include "pixels_source_p.h"
+#include "x_platform.h"
+#include <sys/shm.h>
+
+
+RedPixmapCairo::RedPixmapCairo(int width, int height, RedPixmap::Format format,
+                               bool top_bottom, rgb32_t* pallet, RedWindow *win)
+    : RedPixmap(width, height, format, top_bottom, pallet)
+{
+    cairo_surface_t* cairo_surf = NULL;
+    cairo_t* cairo = NULL;
+    ASSERT(format == RedPixmap::ARGB32 || format == RedPixmap::RGB32 || format == RedPixmap::A1);
+    ASSERT(sizeof(RedDrawable_p) <= PIXELES_SOURCE_OPAQUE_SIZE);
+    XImage *image = NULL;
+    XShmSegmentInfo *shminfo = NULL;
+    _data = NULL;
+    XVisualInfo *vinfo = NULL;
+
+
+    try {
+        cairo_format_t cairo_format;
+
+        if (win) {
+            vinfo = XPlatform::get_vinfo()[win->get_screen_num()];
+        }
+
+        if (vinfo && XShmQueryExtension(XPlatform::get_display())) {
+            int depth;
+
+            switch (format) {
+            case RedPixmap::ARGB32:
+            case RedPixmap::RGB32:
+                depth = XPlatform::get_vinfo()[0]->depth;
+                cairo_format = format == RedPixmap::ARGB32 ? CAIRO_FORMAT_ARGB32 :
+                                                             CAIRO_FORMAT_RGB24;
+                break;
+            case RedPixmap::A1:
+                depth = 1;
+                cairo_format = CAIRO_FORMAT_A1;
+                break;
+            default:
+                THROW("unsupported format %d", format);
+            }
+
+            shminfo = new XShmSegmentInfo;
+            shminfo->shmid = -1;
+            shminfo->shmaddr = 0;
+            ((PixelsSource_p*)get_opaque())->type = PIXELS_SOURCE_TYPE_XSHM_DRAWABLE;
+            memset(shminfo, 0, sizeof(XShmSegmentInfo));
+            image = XShmCreateImage(XPlatform::get_display(), vinfo->visual,
+                                    depth, ZPixmap, NULL, shminfo, width, height);
+            if (!image) {
+                THROW("XShmCreateImage failed");
+            }
+
+            shminfo->shmid = shmget(IPC_PRIVATE, height * _stride, IPC_CREAT | 0777);
+            if (shminfo->shmid < 0) {
+                THROW("shmget failed");
+            }
+            shminfo->shmaddr = (char *)shmat(shminfo->shmid, 0, 0);
+            if (shmctl(shminfo->shmid, IPC_RMID, NULL) == -1) {
+                LOG_WARN("shmctl IPC_RMID failed %s (%d)", strerror(errno), errno);
+            }
+            if (!shminfo->shmaddr) {
+                THROW("shmat failed");
+            }
+            shminfo->readOnly = False;
+            if (!XShmAttach(XPlatform::get_display(), shminfo)) {
+                THROW("XShmAttach failed");
+            }
+
+            /*
+             * Workaround for weird problem that is seen in Fedora 10/11,
+             * spice get bad access error, but I am not sure if the bug is in spice or in X
+             * for now just use this workaround.
+             */
+            XSync(XPlatform::get_display(), False);
+
+            ((PixelsSource_p*)get_opaque())->x_shm_drawable.x_image = image;
+            ((PixelsSource_p*)get_opaque())->x_shm_drawable.shminfo = shminfo;
+            _data = (uint8_t *)shminfo->shmaddr;
+            image->data = (char *)_data;
+        } else {
+            image = new XImage;
+            _data = new uint8_t[height * _stride];
+            ((PixelsSource_p*)get_opaque())->type = PIXELS_SOURCE_TYPE_PIXMAP;
+            ((PixelsSource_p*)get_opaque())->pixmap.x_image = image;
+            memset(image, 0, sizeof(*image));
+            image->width = _width;
+            image->height = _height;
+
+            image->data = (char*)_data;
+            image->byte_order = LSBFirst;
+            image->bitmap_unit = 32;
+            image->bitmap_bit_order = LSBFirst;
+            image->bitmap_pad = 32;
+
+            image->bytes_per_line = _stride;
+            switch (format) {
+            case RedPixmap::ARGB32:
+            case RedPixmap::RGB32:
+                image->depth = XPlatform::get_vinfo()[0]->depth;
+                image->format = ZPixmap;
+                image->bits_per_pixel = 32;
+                image->red_mask = 0x00ff0000;
+                image->green_mask = 0x0000ff00;
+                image->blue_mask = 0x000000ff;
+                cairo_format = format == RedPixmap::ARGB32 ? CAIRO_FORMAT_ARGB32 :
+                                                             CAIRO_FORMAT_RGB24;
+                break;
+            case RedPixmap::A1:
+                image->depth = 1;
+                image->format = XYBitmap;
+                cairo_format = CAIRO_FORMAT_A1;
+                break;
+            default:
+                THROW("unsupported format %d", format);
+            }
+
+            if (!XInitImage(image)) {
+                THROW("init image failed");
+            }
+        }
+        cairo_surf = cairo_image_surface_create_for_data(_data, cairo_format, _width, _height,
+                                                         _stride);
+        if (cairo_surface_status(cairo_surf) != CAIRO_STATUS_SUCCESS) {
+            THROW("surf create failed");
+        }
+
+        cairo = cairo_create(cairo_surf);
+        cairo_surface_destroy(cairo_surf);
+        if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
+            THROW("cairo create failed failed");
+        }
+        if (!(vinfo && XShmQueryExtension(XPlatform::get_display()))) {
+            ((PixelsSource_p*)get_opaque())->pixmap.cairo_surf = cairo_surf;
+        } else {
+            ((PixelsSource_p*)get_opaque())->x_shm_drawable.cairo_surf = cairo_surf;
+        }
+        ((RedDrawable_p*)get_opaque())->cairo = cairo;
+    } catch (...) {
+        if (vinfo && XShmQueryExtension(XPlatform::get_display())) {
+            if (image) {
+                XDestroyImage(image);
+            }
+            if (shminfo) {
+                if (shminfo->shmid >= 0) {
+                    shmctl(shminfo->shmid, IPC_RMID, NULL);
+                }
+                if (shminfo->shmaddr) {
+                    shmdt(shminfo->shmaddr);
+                }
+            }
+        } else {
+            delete image;
+            delete _data;
+        }
+        throw;
+    }
+}
+
+RedPixmapCairo::~RedPixmapCairo()
+{
+    cairo_destroy(((RedDrawable_p*)get_opaque())->cairo);
+    if (((PixelsSource_p*)get_opaque())->type == PIXELS_SOURCE_TYPE_PIXMAP) {
+        delete ((PixelsSource_p*)get_opaque())->pixmap.x_image;
+        delete _data;
+    } else {
+        XShmSegmentInfo *shminfo = ((PixelsSource_p*)get_opaque())->x_shm_drawable.shminfo;
+        XShmDetach(XPlatform::get_display(), shminfo);
+        XDestroyImage(((PixelsSource_p*)get_opaque())->x_shm_drawable.x_image);
+        shmdt(shminfo->shmaddr);
+        delete shminfo;
+    }
+}
+
diff --git a/client/x11/red_pixmap_gl.cpp b/client/x11/red_pixmap_gl.cpp
new file mode 100644
index 00000000..886bb0b3
--- /dev/null
+++ b/client/x11/red_pixmap_gl.cpp
@@ -0,0 +1,317 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glext.h>
+#include <X11/Xlib.h>
+
+#include "common.h"
+#include "red_pixmap_gl.h"
+#include "debug.h"
+#include "utils.h"
+#include "gl_utils.h"
+#include "pixels_source_p.h"
+#include "x_platform.h"
+#include "red_window_p.h"
+
+
+RedPixmapGL::RedPixmapGL(int width, int height, RedPixmap::Format format,
+                         bool top_bottom, rgb32_t* pallet, RedWindow *win,
+                         RenderType rendertype)
+    : RedPixmap(width, height, format, top_bottom, pallet)
+{
+    GLuint fbo;
+    GLuint tex;
+    GLuint stencil_tex = 0;
+    Win xwin;
+    //GLint max_texture_size;
+
+    ASSERT(format == RedPixmap::ARGB32 || format == RedPixmap::RGB32 || format == RedPixmap::A1);
+    ASSERT(sizeof(RedDrawable_p) <= PIXELES_SOURCE_OPAQUE_SIZE);
+
+    ((PixelsSource_p*)get_opaque())->type = PIXELS_SOURCE_TYPE_GL_TEXTURE;
+
+    _glcont = win->create_context_gl();
+    if (!_glcont) {
+        THROW("glXCreateContext failed");
+    }
+
+    win->set_gl_context(_glcont);
+
+    xwin = ((RedWindow_p*)win)->get_window();
+
+    /*glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
+    if (width > max_texture_size || height > max_texture_size) {
+        throw Exception(fmt("%s: unsuported max %|| width %|| height %||")
+                             % __FUNCTION__
+                             % max_texture_size
+                             % width
+                             % height);
+    }*/
+
+    if (rendertype == RENDER_TYPE_FBO) {
+        glXMakeCurrent(XPlatform::get_display(), xwin, _glcont);
+        if (!gluCheckExtension((GLubyte *)"GL_EXT_framebuffer_object",
+                               glGetString(GL_EXTENSIONS))) {
+            glXMakeCurrent(XPlatform::get_display(), 0, 0);
+            glXDestroyContext(XPlatform::get_display(), _glcont);
+            THROW("no GL_EXT_framebuffer_object extension");
+        }
+        glEnable(GL_TEXTURE_2D);
+        glGenFramebuffersEXT(1, &fbo);
+        glGenTextures(1, &tex);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+
+        glBindTexture(GL_TEXTURE_2D, tex);
+
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_get_to_power_two(width),
+                     gl_get_to_power_two(height), 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                     NULL);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                                  GL_TEXTURE_2D, tex, 0);
+
+
+        glGenTextures(1, &stencil_tex);
+        glBindTexture(GL_TEXTURE_2D, stencil_tex);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_STENCIL_EXT,
+                     gl_get_to_power_two(width), gl_get_to_power_two(height), 0,
+                     GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, NULL);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
+                                  GL_DEPTH_ATTACHMENT_EXT,
+                                  GL_TEXTURE_2D, stencil_tex, 0);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
+                                  GL_STENCIL_ATTACHMENT_EXT,
+                                  GL_TEXTURE_2D, stencil_tex, 0);
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+        ((PixelsSource_p*)get_opaque())->gl.fbo = fbo;
+        win->set_render_fbo(fbo);
+    } else {
+        GLXPbuffer pbuff;
+
+        pbuff = win->create_pbuff(gl_get_to_power_two(width),
+                                  gl_get_to_power_two(height));
+        if (!pbuff) {
+            glXDestroyContext(XPlatform::get_display(), _glcont);
+            THROW("pbuff creation failed");
+        }
+        glXMakeCurrent(XPlatform::get_display(), pbuff, _glcont);
+        glEnable(GL_TEXTURE_2D);
+        glGenTextures(1, &tex);
+        glBindTexture(GL_TEXTURE_2D, tex);
+
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_get_to_power_two(width),
+                     gl_get_to_power_two(height), 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                     NULL);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+        ((PixelsSource_p*)get_opaque())->gl.pbuff = pbuff;
+        win->set_render_pbuff(pbuff);
+    }
+
+    ((PixelsSource_p*)get_opaque())->gl.stencil_tex = stencil_tex;
+    ((PixelsSource_p*)get_opaque())->gl.tex = tex;
+    ((PixelsSource_p*)get_opaque())->gl.width = width;
+    ((PixelsSource_p*)get_opaque())->gl.height = height;
+    ((PixelsSource_p*)get_opaque())->gl.width_powed = gl_get_to_power_two(width);
+    ((PixelsSource_p*)get_opaque())->gl.height_powed = gl_get_to_power_two(height);
+    ((PixelsSource_p*)get_opaque())->gl.win = xwin;
+    ((PixelsSource_p*)get_opaque())->gl.rendertype = rendertype;
+    ((PixelsSource_p*)get_opaque())->gl.context = _glcont;
+
+    _textures_lost = false;
+
+    GLC_ERROR_TEST_FINISH;
+}
+
+void RedPixmapGL::textures_lost()
+{
+    _textures_lost = true;
+}
+
+void RedPixmapGL::touch_context()
+{
+    Win win;
+    GLXPbuffer pbuff;
+    RenderType rendertype;
+
+    rendertype = ((PixelsSource_p*)get_opaque())->gl.rendertype;
+    if (rendertype == RENDER_TYPE_FBO) {
+        win = ((PixelsSource_p*)get_opaque())->gl.win;
+        if (_glcont) {
+            glXMakeCurrent(XPlatform::get_display(), win, _glcont);
+        }
+    } else {
+        pbuff = ((PixelsSource_p*)get_opaque())->gl.pbuff;
+        glXMakeCurrent(XPlatform::get_display(), pbuff, _glcont);
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void RedPixmapGL::update_texture(const Rect *bbox)
+{
+    RenderType rendertype;
+    GLuint tex;
+    int width_powed;
+    int height_powed;
+    int height;
+    int width;
+
+    rendertype = ((PixelsSource_p*)get_opaque())->gl.rendertype;
+
+    if (rendertype == RENDER_TYPE_PBUFF) {
+        int tex_x, tex_y;
+        int vertex_x1, vertex_x2;
+        int vertex_y1, vertex_y2;
+        int is_enabled;
+        GLint prev_tex;
+
+        width_powed = ((PixelsSource_p*)get_opaque())->gl.width_powed;
+        height_powed = ((PixelsSource_p*)get_opaque())->gl.height_powed;
+        width = ((PixelsSource_p*)get_opaque())->gl.width;
+        height = ((PixelsSource_p*)get_opaque())->gl.height;
+
+        tex = ((PixelsSource_p*)get_opaque())->gl.tex;
+
+        tex_x = bbox->left;
+        tex_y = height - bbox->bottom;
+        vertex_x1 = bbox->left;
+        vertex_y1 = height - bbox->bottom;
+        vertex_x2 = vertex_x1 + (bbox->right - bbox->left);
+        vertex_y2 = vertex_y1 + (bbox->bottom - bbox->top);
+
+        is_enabled = glIsEnabled(GL_TEXTURE_2D);
+        if (!is_enabled) {
+            glEnable(GL_TEXTURE_2D);
+        } else {
+            glGetIntegerv(GL_TEXTURE_BINDING_2D, &prev_tex);
+        }
+        glBindTexture(GL_TEXTURE_2D, tex);
+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, tex_x, tex_y, vertex_x1,
+                            vertex_y1, vertex_x2 - vertex_x1,
+                            vertex_y2 - vertex_y1);
+        if (!is_enabled) {
+            glBindTexture(GL_TEXTURE_2D, 0);
+            glDisable(GL_TEXTURE_2D);
+        } else {
+            glBindTexture(GL_TEXTURE_2D, prev_tex);
+        }
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void RedPixmapGL::pre_copy()
+{
+    glFlush();
+
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TEXTURE_BIT |
+                 GL_TRANSFORM_BIT);
+
+    glMatrixMode(GL_TEXTURE);
+    glPushMatrix();
+    glLoadIdentity();
+
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    gluOrtho2D(0, ((PixelsSource_p*)get_opaque())->gl.width, 0,
+               ((PixelsSource_p*)get_opaque())->gl.height);
+
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+    glViewport(0, 0, ((PixelsSource_p*)get_opaque())->gl.width,
+               ((PixelsSource_p*)get_opaque())->gl.height);
+
+
+    glDisable(GL_TEXTURE_GEN_S);
+    glDisable(GL_TEXTURE_GEN_T);
+    glDisable(GL_BLEND);
+    glDisable(GL_ALPHA_TEST);
+    glDisable(GL_COLOR_LOGIC_OP);
+
+    glColor3f(1, 1, 1);
+}
+
+void RedPixmapGL::past_copy()
+{
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_TEXTURE);
+    glPopMatrix();
+
+    glPopAttrib();
+    glFlush();
+}
+
+RedPixmapGL::~RedPixmapGL()
+{
+    GLXPbuffer pbuff;
+    GLuint fbo;
+    RenderType rendertype;
+    GLuint tex;
+    GLuint stencil_tex;
+
+    /*
+     * GL textures might be destroyed by res change.
+     */
+    if (!_textures_lost) {
+        tex = ((PixelsSource_p*)get_opaque())->gl.tex;
+        stencil_tex = ((PixelsSource_p*)get_opaque())->gl.stencil_tex;
+        if (tex) {
+            glDeleteTextures(1, &tex);
+        }
+        if (stencil_tex) {
+            glDeleteTextures(1, &stencil_tex);
+        }
+        if (_glcont) {
+            glXDestroyContext(XPlatform::get_display(), _glcont);
+        }
+    }
+
+    rendertype = ((PixelsSource_p*)get_opaque())->gl.rendertype;
+    if (rendertype == RENDER_TYPE_FBO) {
+        fbo = ((PixelsSource_p*)get_opaque())->gl.fbo;
+        if (fbo) {
+            glDeleteFramebuffersEXT(1, &fbo);
+        }
+    } else {
+        pbuff = ((PixelsSource_p*)get_opaque())->gl.pbuff;
+        glXDestroyPbuffer(XPlatform::get_display(), pbuff);
+    }
+
+    /*
+     * Both tex and stenctil_tex are textures and therefore they are destroyed
+     * when the context is gone, so we dont free them here as they might have
+     * already been destroyed.
+     */
+    GLC_ERROR_TEST_FINISH;
+}
+
diff --git a/client/x11/red_window.cpp b/client/x11/red_window.cpp
new file mode 100644
index 00000000..9cce15f6
--- /dev/null
+++ b/client/x11/red_window.cpp
@@ -0,0 +1,1917 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define GL_GLEXT_PROTOTYPES
+#include "common.h"
+#include <X11/Xlib.h>
+#include <X11/Xresource.h>
+#include <X11/keysymdef.h>
+#include <X11/Xatom.h>
+#include <X11/XKBlib.h>
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glx.h>
+#include <GL/glext.h>
+#include <stdio.h>
+
+#include "red_window.h"
+#include "utils.h"
+#include "gl_utils.h"
+#include "debug.h"
+#include "platform.h"
+#include "x_platform.h"
+#include "pixels_source_p.h"
+#include "red.h"
+#include "region.h"
+#include "red_pixmap_gl.h"
+#include "red_pixmap_gl.h"
+#include "x_icon.h"
+
+
+#define X_RETRIES 10
+#define X_RETRY_DELAY_MICRO (1000 * 100)
+#define RAISE_RETRIES X_RETRIES
+#define Z_POSITION_RETRIES X_RETRIES
+#define GET_POSITION_RETRIES X_RETRIES
+#define GET_VIS_REGION_RETRIES X_RETRIES
+#define MOUSE_GRAB_RETRIES X_RETRIES
+
+static Display* x_display = NULL;
+static XContext user_data_context;
+static bool using_evdev = false;
+
+static Atom wm_protocol_atom;
+static Atom wm_delete_window_atom;
+
+static Atom wm_desktop;
+static Atom wm_current_desktop;
+
+static Atom wm_state;
+static Atom wm_state_above;
+static Atom wm_state_fullscreen;
+
+static Atom wm_user_time;
+
+#define USE_X11_KEYCODE
+
+#ifdef USE_X11_KEYCODE
+
+enum EvdevKeyCode {
+    EVDEV_KEYCODE_ESCAPE = 9,
+    EVDEV_KEYCODE_1,
+    EVDEV_KEYCODE_2,
+    EVDEV_KEYCODE_3,
+    EVDEV_KEYCODE_4,
+    EVDEV_KEYCODE_5,
+    EVDEV_KEYCODE_6,
+    EVDEV_KEYCODE_7,
+    EVDEV_KEYCODE_8,
+    EVDEV_KEYCODE_9,
+    EVDEV_KEYCODE_0,
+    EVDEV_KEYCODE_MINUS,
+    EVDEV_KEYCODE_EQUAL,
+    EVDEV_KEYCODE_BACK_SPACE,
+    EVDEV_KEYCODE_TAB,
+    EVDEV_KEYCODE_Q,
+    EVDEV_KEYCODE_W,
+    EVDEV_KEYCODE_E,
+    EVDEV_KEYCODE_R,
+    EVDEV_KEYCODE_T,
+    EVDEV_KEYCODE_Y,
+    EVDEV_KEYCODE_U,
+    EVDEV_KEYCODE_I,
+    EVDEV_KEYCODE_O,
+    EVDEV_KEYCODE_P,
+    EVDEV_KEYCODE_L_BRACKET,
+    EVDEV_KEYCODE_R_BRACKET,
+    EVDEV_KEYCODE_RETURN,
+    EVDEV_KEYCODE_L_CONTROL,
+    EVDEV_KEYCODE_A,
+    EVDEV_KEYCODE_S,
+    EVDEV_KEYCODE_D,
+    EVDEV_KEYCODE_F,
+    EVDEV_KEYCODE_G,
+    EVDEV_KEYCODE_H,
+    EVDEV_KEYCODE_J,
+    EVDEV_KEYCODE_K,
+    EVDEV_KEYCODE_L,
+    EVDEV_KEYCODE_SEMICOLON,
+    EVDEV_KEYCODE_APOSTROPH,
+    EVDEV_KEYCODE_BACKQUAT,
+    EVDEV_KEYCODE_L_SHIFT,
+    EVDEV_KEYCODE_BACKSLASH,
+    EVDEV_KEYCODE_Z,
+    EVDEV_KEYCODE_X,
+    EVDEV_KEYCODE_C,
+    EVDEV_KEYCODE_V,
+    EVDEV_KEYCODE_B,
+    EVDEV_KEYCODE_N,
+    EVDEV_KEYCODE_M,
+    EVDEV_KEYCODE_COMMA,
+    EVDEV_KEYCODE_PERIOD,
+    EVDEV_KEYCODE_SLASH,
+    EVDEV_KEYCODE_R_SHIFT,
+    EVDEV_KEYCODE_PAD_MULTIPLY,
+    EVDEV_KEYCODE_L_ALT,
+    EVDEV_KEYCODE_SPACE,
+    EVDEV_KEYCODE_CAPS_LOCK,
+    EVDEV_KEYCODE_F1,
+    EVDEV_KEYCODE_F2,
+    EVDEV_KEYCODE_F3,
+    EVDEV_KEYCODE_F4,
+    EVDEV_KEYCODE_F5,
+    EVDEV_KEYCODE_F6,
+    EVDEV_KEYCODE_F7,
+    EVDEV_KEYCODE_F8,
+    EVDEV_KEYCODE_F9,
+    EVDEV_KEYCODE_F10,
+    EVDEV_KEYCODE_NUM_LOCK,
+    EVDEV_KEYCODE_SCROLL_LOCK,
+    EVDEV_KEYCODE_PAD_7,
+    EVDEV_KEYCODE_PAD_8,
+    EVDEV_KEYCODE_PAD_9,
+    EVDEV_KEYCODE_PAD_SUBTRACT,
+    EVDEV_KEYCODE_PAD_4,
+    EVDEV_KEYCODE_PAD_5,
+    EVDEV_KEYCODE_PAD_6,
+    EVDEV_KEYCODE_PAD_ADD,
+    EVDEV_KEYCODE_PAD_1,
+    EVDEV_KEYCODE_PAD_2,
+    EVDEV_KEYCODE_PAD_3,
+    EVDEV_KEYCODE_PAD_0,
+    EVDEV_KEYCODE_PAD_DEL,
+    EVDEV_KEYCODE_EUROPEAN = 94,
+    EVDEV_KEYCODE_F11,
+    EVDEV_KEYCODE_F12,
+    EVDEV_KEYCODE_JAPANESE_BACKSLASH,
+    EVDEV_KEYCODE_JAPANESE_HENKAN = 100,
+    EVDEV_KEYCODE_JAPANESE_HIRAGANA_KATAKANA,
+    EVDEV_KEYCODE_JAPANESE_MUHENKAN,
+    EVDEV_KEYCODE_PAD_ENTER = 104,
+    EVDEV_KEYCODE_R_CONTROL,
+    EVDEV_KEYCODE_PAD_DEVIDE,
+    EVDEV_KEYCODE_PRINT,
+    EVDEV_KEYCODE_R_ALT,
+    EVDEV_KEYCODE_HOME = 110,
+    EVDEV_KEYCODE_UP,
+    EVDEV_KEYCODE_PAGE_UP,
+    EVDEV_KEYCODE_LEFT,
+    EVDEV_KEYCODE_RIGHT,
+    EVDEV_KEYCODE_END,
+    EVDEV_KEYCODE_DOWN,
+    EVDEV_KEYCODE_PAGE_DOWN,
+    EVDEV_KEYCODE_INSERT,
+    EVDEV_KEYCODE_DELETE,
+    EVDEV_KEYCODE_PAUSE = 127,
+    EVDEV_KEYCODE_HANGUL = 130,
+    EVDEV_KEYCODE_HANGUL_HANJA,
+    EVDEV_KEYCODE_YEN,
+    EVDEV_KEYCODE_L_COMMAND,
+    EVDEV_KEYCODE_R_COMMAND,
+    EVDEV_KEYCODE_MENU,
+};
+
+enum KbdKeyCode {
+    KBD_KEYCODE_ESCAPE = 9,
+    KBD_KEYCODE_1,
+    KBD_KEYCODE_2,
+    KBD_KEYCODE_3,
+    KBD_KEYCODE_4,
+    KBD_KEYCODE_5,
+    KBD_KEYCODE_6,
+    KBD_KEYCODE_7,
+    KBD_KEYCODE_8,
+    KBD_KEYCODE_9,
+    KBD_KEYCODE_0,
+    KBD_KEYCODE_MINUS,
+    KBD_KEYCODE_EQUAL,
+    KBD_KEYCODE_BACK_SPACE,
+    KBD_KEYCODE_TAB,
+    KBD_KEYCODE_Q,
+    KBD_KEYCODE_W,
+    KBD_KEYCODE_E,
+    KBD_KEYCODE_R,
+    KBD_KEYCODE_T,
+    KBD_KEYCODE_Y,
+    KBD_KEYCODE_U,
+    KBD_KEYCODE_I,
+    KBD_KEYCODE_O,
+    KBD_KEYCODE_P,
+    KBD_KEYCODE_L_BRACKET,
+    KBD_KEYCODE_R_BRACKET,
+    KBD_KEYCODE_RETURN,
+    KBD_KEYCODE_L_CONTROL,
+    KBD_KEYCODE_A,
+    KBD_KEYCODE_S,
+    KBD_KEYCODE_D,
+    KBD_KEYCODE_F,
+    KBD_KEYCODE_G,
+    KBD_KEYCODE_H,
+    KBD_KEYCODE_J,
+    KBD_KEYCODE_K,
+    KBD_KEYCODE_L,
+    KBD_KEYCODE_SEMICOLON,
+    KBD_KEYCODE_APOSTROPH,
+    KBD_KEYCODE_BACKQUAT,
+    KBD_KEYCODE_L_SHIFT,
+    KBD_KEYCODE_BACKSLASH,
+    KBD_KEYCODE_Z,
+    KBD_KEYCODE_X,
+    KBD_KEYCODE_C,
+    KBD_KEYCODE_V,
+    KBD_KEYCODE_B,
+    KBD_KEYCODE_N,
+    KBD_KEYCODE_M,
+    KBD_KEYCODE_COMMA,
+    KBD_KEYCODE_PERIOD,
+    KBD_KEYCODE_SLASH,
+    KBD_KEYCODE_R_SHIFT,
+    KBD_KEYCODE_PAD_MULTIPLY,
+    KBD_KEYCODE_L_ALT,
+    KBD_KEYCODE_SPACE,
+    KBD_KEYCODE_CAPS_LOCK,
+    KBD_KEYCODE_F1,
+    KBD_KEYCODE_F2,
+    KBD_KEYCODE_F3,
+    KBD_KEYCODE_F4,
+    KBD_KEYCODE_F5,
+    KBD_KEYCODE_F6,
+    KBD_KEYCODE_F7,
+    KBD_KEYCODE_F8,
+    KBD_KEYCODE_F9,
+    KBD_KEYCODE_F10,
+    KBD_KEYCODE_NUM_LOCK,
+    KBD_KEYCODE_SCROLL_LOCK,
+    KBD_KEYCODE_PAD_7,
+    KBD_KEYCODE_PAD_8,
+    KBD_KEYCODE_PAD_9,
+    KBD_KEYCODE_PAD_SUBTRACT,
+    KBD_KEYCODE_PAD_4,
+    KBD_KEYCODE_PAD_5,
+    KBD_KEYCODE_PAD_6,
+    KBD_KEYCODE_PAD_ADD,
+    KBD_KEYCODE_PAD_1,
+    KBD_KEYCODE_PAD_2,
+    KBD_KEYCODE_PAD_3,
+    KBD_KEYCODE_PAD_0,
+    KBD_KEYCODE_PAD_DEL,
+    KBD_KEYCODE_EUROPEAN = 94,
+    KBD_KEYCODE_F11,
+    KBD_KEYCODE_F12,
+    KBD_KEYCODE_HOME,
+    KBD_KEYCODE_UP,
+    KBD_KEYCODE_PAGE_UP,
+    KBD_KEYCODE_LEFT,
+    KBD_KEYCODE_RIGHT = 102,
+    KBD_KEYCODE_END,
+    KBD_KEYCODE_DOWN,
+    KBD_KEYCODE_PAGE_DOWN,
+    KBD_KEYCODE_INSERT,
+    KBD_KEYCODE_DELETE,
+    KBD_KEYCODE_PAD_ENTER,
+    KBD_KEYCODE_R_CONTROL,
+    KBD_KEYCODE_PAUSE,
+    KBD_KEYCODE_PRINT,
+    KBD_KEYCODE_PAD_DEVIDE,
+    KBD_KEYCODE_R_ALT,
+    KBD_KEYCODE_L_COMMAND = 115,
+    KBD_KEYCODE_R_COMMAND,
+    KBD_KEYCODE_MENU,
+    KBD_KEYCODE_JAPANESE_HENKAN = 129,
+    KBD_KEYCODE_JAPANESE_MUHENKAN = 131,
+    KBD_KEYCODE_YEN = 133,
+    KBD_KEYCODE_JAPANESE_HIRAGANA_KATAKANA = 208,
+    KBD_KEYCODE_HANGUL_HANJA,
+    KBD_KEYCODE_HANGUL,
+    KBD_KEYCODE_JAPANESE_BACKSLASH,
+};
+
+static void query_keyboard()
+{
+    XkbDescPtr kbd_desk = XkbGetKeyboard(x_display, XkbAllComponentsMask, XkbUseCoreKbd);
+    if (!kbd_desk) {
+        LOG_WARN("get keyboard failed");
+        return;
+    }
+
+    char* keycodes = XGetAtomName(x_display, kbd_desk->names->keycodes);
+
+    if (keycodes) {
+        if (strstr(keycodes, "evdev")) {
+            using_evdev = true;
+        }
+        XFree(keycodes);
+    } else {
+        LOG_WARN("get name failed");
+    }
+    XkbFreeClientMap(kbd_desk, XkbAllComponentsMask, True);
+}
+
+static RedKey keycode_map[256];
+
+#define INIT_MAP                                                                    \
+    KEYMAP(KEYCODE_ESCAPE, REDKEY_ESCAPE);                                          \
+    KEYMAP(KEYCODE_1, REDKEY_1);                                                    \
+    KEYMAP(KEYCODE_2, REDKEY_2);                                                    \
+    KEYMAP(KEYCODE_3, REDKEY_3);                                                    \
+    KEYMAP(KEYCODE_4, REDKEY_4);                                                    \
+    KEYMAP(KEYCODE_5, REDKEY_5);                                                    \
+    KEYMAP(KEYCODE_6, REDKEY_6);                                                    \
+    KEYMAP(KEYCODE_7, REDKEY_7);                                                    \
+    KEYMAP(KEYCODE_8, REDKEY_8);                                                    \
+    KEYMAP(KEYCODE_9, REDKEY_9);                                                    \
+    KEYMAP(KEYCODE_0, REDKEY_0);                                                    \
+    KEYMAP(KEYCODE_MINUS, REDKEY_MINUS);                                            \
+    KEYMAP(KEYCODE_EQUAL, REDKEY_EQUALS);                                           \
+    KEYMAP(KEYCODE_BACK_SPACE, REDKEY_BACKSPACE);                                   \
+    KEYMAP(KEYCODE_TAB, REDKEY_TAB);                                                \
+    KEYMAP(KEYCODE_Q, REDKEY_Q);                                                    \
+    KEYMAP(KEYCODE_W, REDKEY_W);                                                    \
+    KEYMAP(KEYCODE_E, REDKEY_E);                                                    \
+    KEYMAP(KEYCODE_R, REDKEY_R);                                                    \
+    KEYMAP(KEYCODE_T, REDKEY_T);                                                    \
+    KEYMAP(KEYCODE_Y, REDKEY_Y);                                                    \
+    KEYMAP(KEYCODE_U, REDKEY_U);                                                    \
+    KEYMAP(KEYCODE_I, REDKEY_I);                                                    \
+    KEYMAP(KEYCODE_O, REDKEY_O);                                                    \
+    KEYMAP(KEYCODE_P, REDKEY_P);                                                    \
+    KEYMAP(KEYCODE_L_BRACKET, REDKEY_L_BRACKET);                                    \
+    KEYMAP(KEYCODE_R_BRACKET, REDKEY_R_BRACKET);                                    \
+    KEYMAP(KEYCODE_RETURN, REDKEY_ENTER);                                           \
+    KEYMAP(KEYCODE_L_CONTROL, REDKEY_L_CTRL);                                       \
+    KEYMAP(KEYCODE_A, REDKEY_A);                                                    \
+    KEYMAP(KEYCODE_S, REDKEY_S);                                                    \
+    KEYMAP(KEYCODE_D, REDKEY_D);                                                    \
+    KEYMAP(KEYCODE_F, REDKEY_F);                                                    \
+    KEYMAP(KEYCODE_G, REDKEY_G);                                                    \
+    KEYMAP(KEYCODE_H, REDKEY_H);                                                    \
+    KEYMAP(KEYCODE_J, REDKEY_J);                                                    \
+    KEYMAP(KEYCODE_K, REDKEY_K);                                                    \
+    KEYMAP(KEYCODE_L, REDKEY_L);                                                    \
+    KEYMAP(KEYCODE_SEMICOLON, REDKEY_SEMICOLON);                                    \
+    KEYMAP(KEYCODE_APOSTROPH, REDKEY_QUOTE);                                        \
+    KEYMAP(KEYCODE_BACKQUAT, REDKEY_BACK_QUOTE);                                    \
+    KEYMAP(KEYCODE_L_SHIFT, REDKEY_L_SHIFT);                                        \
+    KEYMAP(KEYCODE_BACKSLASH, REDKEY_BACK_SLASH);                                   \
+    KEYMAP(KEYCODE_Z, REDKEY_Z);                                                    \
+    KEYMAP(KEYCODE_X, REDKEY_X);                                                    \
+    KEYMAP(KEYCODE_C, REDKEY_C);                                                    \
+    KEYMAP(KEYCODE_V, REDKEY_V);                                                    \
+    KEYMAP(KEYCODE_B, REDKEY_B);                                                    \
+    KEYMAP(KEYCODE_N, REDKEY_N);                                                    \
+    KEYMAP(KEYCODE_M, REDKEY_M);                                                    \
+    KEYMAP(KEYCODE_COMMA, REDKEY_COMMA);                                            \
+    KEYMAP(KEYCODE_PERIOD, REDKEY_PERIOD);                                          \
+    KEYMAP(KEYCODE_SLASH, REDKEY_SLASH);                                            \
+    KEYMAP(KEYCODE_R_SHIFT, REDKEY_R_SHIFT);                                        \
+    KEYMAP(KEYCODE_PAD_MULTIPLY, REDKEY_PAD_MULTIPLY);                              \
+    KEYMAP(KEYCODE_L_ALT, REDKEY_L_ALT);                                            \
+    KEYMAP(KEYCODE_SPACE, REDKEY_SPACE);                                            \
+    KEYMAP(KEYCODE_CAPS_LOCK, REDKEY_CAPS_LOCK);                                    \
+    KEYMAP(KEYCODE_F1, REDKEY_F1);                                                  \
+    KEYMAP(KEYCODE_F2, REDKEY_F2);                                                  \
+    KEYMAP(KEYCODE_F3, REDKEY_F3);                                                  \
+    KEYMAP(KEYCODE_F4, REDKEY_F4);                                                  \
+    KEYMAP(KEYCODE_F5, REDKEY_F5);                                                  \
+    KEYMAP(KEYCODE_F6, REDKEY_F6);                                                  \
+    KEYMAP(KEYCODE_F7, REDKEY_F7);                                                  \
+    KEYMAP(KEYCODE_F8, REDKEY_F8);                                                  \
+    KEYMAP(KEYCODE_F9, REDKEY_F9);                                                  \
+    KEYMAP(KEYCODE_F10, REDKEY_F10);                                                \
+    KEYMAP(KEYCODE_NUM_LOCK, REDKEY_NUM_LOCK);                                      \
+    KEYMAP(KEYCODE_SCROLL_LOCK, REDKEY_SCROLL_LOCK);                                \
+    KEYMAP(KEYCODE_PAD_7, REDKEY_PAD_7);                                            \
+    KEYMAP(KEYCODE_PAD_8, REDKEY_PAD_8);                                            \
+    KEYMAP(KEYCODE_PAD_9, REDKEY_PAD_9);                                            \
+    KEYMAP(KEYCODE_PAD_SUBTRACT, REDKEY_PAD_MINUS);                                 \
+    KEYMAP(KEYCODE_PAD_4, REDKEY_PAD_4);                                            \
+    KEYMAP(KEYCODE_PAD_5, REDKEY_PAD_5);                                            \
+    KEYMAP(KEYCODE_PAD_6, REDKEY_PAD_6);                                            \
+    KEYMAP(KEYCODE_PAD_ADD, REDKEY_PAD_PLUS);                                       \
+    KEYMAP(KEYCODE_PAD_1, REDKEY_PAD_1);                                            \
+    KEYMAP(KEYCODE_PAD_2, REDKEY_PAD_2);                                            \
+    KEYMAP(KEYCODE_PAD_3, REDKEY_PAD_3);                                            \
+    KEYMAP(KEYCODE_PAD_0, REDKEY_PAD_0);                                            \
+    KEYMAP(KEYCODE_PAD_DEL, REDKEY_PAD_POINT);                                      \
+    KEYMAP(KEYCODE_EUROPEAN, REDKEY_EUROPEAN);                                      \
+    KEYMAP(KEYCODE_F11, REDKEY_F11);                                                \
+    KEYMAP(KEYCODE_F12, REDKEY_F12);                                                \
+    KEYMAP(KEYCODE_JAPANESE_BACKSLASH, REDKEY_JAPANESE_BACKSLASH);                  \
+    KEYMAP(KEYCODE_JAPANESE_HENKAN, REDKEY_JAPANESE_HENKAN);                        \
+    KEYMAP(KEYCODE_JAPANESE_HIRAGANA_KATAKANA, REDKEY_JAPANESE_HIRAGANA_KATAKANA);  \
+    KEYMAP(KEYCODE_JAPANESE_MUHENKAN, REDKEY_JAPANESE_MUHENKAN);                    \
+    KEYMAP(KEYCODE_PAD_ENTER, REDKEY_PAD_ENTER);                                    \
+    KEYMAP(KEYCODE_R_CONTROL, REDKEY_R_CTRL);                                       \
+    KEYMAP(KEYCODE_PAD_DEVIDE, REDKEY_PAD_DIVIDE);                                  \
+    KEYMAP(KEYCODE_PRINT, REDKEY_CTRL_PRINT_SCREEN);                                \
+    KEYMAP(KEYCODE_R_ALT, REDKEY_R_ALT);                                            \
+    KEYMAP(KEYCODE_HOME, REDKEY_HOME);                                              \
+    KEYMAP(KEYCODE_UP, REDKEY_UP);                                                  \
+    KEYMAP(KEYCODE_PAGE_UP, REDKEY_PAGEUP);                                         \
+    KEYMAP(KEYCODE_LEFT, REDKEY_LEFT);                                              \
+    KEYMAP(KEYCODE_RIGHT, REDKEY_RIGHT);                                            \
+    KEYMAP(KEYCODE_END, REDKEY_END);                                                \
+    KEYMAP(KEYCODE_DOWN, REDKEY_DOWN);                                              \
+    KEYMAP(KEYCODE_PAGE_DOWN, REDKEY_PAGEDOWN);                                     \
+    KEYMAP(KEYCODE_INSERT, REDKEY_INSERT);                                          \
+    KEYMAP(KEYCODE_DELETE, REDKEY_DELETE);                                          \
+    KEYMAP(KEYCODE_PAUSE, REDKEY_PAUSE);                                            \
+                                                                                    \
+    KEYMAP(KEYCODE_YEN, REDKEY_JAPANESE_YEN);                                       \
+    KEYMAP(KEYCODE_L_COMMAND, REDKEY_LEFT_CMD);                                     \
+    KEYMAP(KEYCODE_R_COMMAND, REDKEY_RIGHT_CMD);                                    \
+    KEYMAP(KEYCODE_MENU, REDKEY_MENU);                                              \
+    KEYMAP(KEYCODE_HANGUL, REDKEY_KOREAN_HANGUL);                                   \
+    KEYMAP(KEYCODE_HANGUL_HANJA, REDKEY_KOREAN_HANGUL_HANJA);
+
+static void init_evdev_map()
+{
+    #define KEYMAP(key_code, red_key)  keycode_map[EVDEV_##key_code] = red_key
+    INIT_MAP;
+    #undef KEYMAP
+}
+
+static void init_kbd_map()
+{
+    #define KEYMAP(key_code, red_key)  keycode_map[KBD_##key_code] = red_key
+    INIT_MAP;
+    #undef KEYMAP
+}
+
+static void init_key_map()
+{
+    query_keyboard();
+    memset(keycode_map, 0, sizeof(keycode_map));
+    if (using_evdev) {
+        LOG_INFO("using evdev mapping");
+        init_evdev_map();
+    } else {
+        LOG_INFO("using kbd mapping");
+        init_kbd_map();
+    }
+}
+
+static inline RedKey to_red_key_code(unsigned int keycode)
+{
+    if (keycode > 255) {
+        return REDKEY_INVALID;
+    }
+    return keycode_map[keycode];
+}
+
+#else
+
+static RedKey key_table_0xff[256]; //miscellany
+
+static RedKey key_table_0x00[256]; //Latin 1
+
+static RedKey key_table_0xfe[256]; //Keyboard (XKB) Extension
+
+#define INIT_KEY(x, red) key_table_0xff[x & 0xff] = red;
+
+static void init_key_table_0xff()
+{
+    for (int i = 0; i < sizeof(key_table_0xff) / sizeof(key_table_0xff[0]); i++) {
+        key_table_0xff[i] = REDKEY_INVALID;
+    }
+
+    INIT_KEY(XK_Escape, REDKEY_ESCAPE);
+    INIT_KEY(XK_BackSpace, REDKEY_BACKSPACE);
+    INIT_KEY(XK_Tab, REDKEY_TAB);
+    INIT_KEY(XK_Return, REDKEY_ENTER);
+    INIT_KEY(XK_Control_L, REDKEY_L_CTRL);
+    INIT_KEY(XK_Shift_L, REDKEY_L_SHIFT);
+    INIT_KEY(XK_Shift_R, REDKEY_R_SHIFT);
+    INIT_KEY(XK_KP_Multiply, REDKEY_PAD_MULTIPLY);
+    INIT_KEY(XK_Alt_L, REDKEY_L_ALT);
+    INIT_KEY(XK_Caps_Lock, REDKEY_CAPS_LOCK);
+    INIT_KEY(XK_F1, REDKEY_F1);
+    INIT_KEY(XK_F2, REDKEY_F2);
+    INIT_KEY(XK_F3, REDKEY_F3);
+    INIT_KEY(XK_F4, REDKEY_F4);
+    INIT_KEY(XK_F5, REDKEY_F5);
+    INIT_KEY(XK_F6, REDKEY_F6);
+    INIT_KEY(XK_F7, REDKEY_F7);
+    INIT_KEY(XK_F8, REDKEY_F8);
+    INIT_KEY(XK_F9, REDKEY_F9);
+    INIT_KEY(XK_F10, REDKEY_F10);
+
+    INIT_KEY(XK_Num_Lock, REDKEY_NUM_LOCK);
+    INIT_KEY(XK_Scroll_Lock, REDKEY_SCROLL_LOCK);
+    INIT_KEY(XK_KP_7, REDKEY_PAD_7);
+    INIT_KEY(XK_KP_Home, REDKEY_PAD_7);
+    INIT_KEY(XK_KP_8, REDKEY_PAD_8);
+    INIT_KEY(XK_KP_Up, REDKEY_PAD_8);
+    INIT_KEY(XK_KP_9, REDKEY_PAD_9);
+    INIT_KEY(XK_KP_Page_Up, REDKEY_PAD_9);
+    INIT_KEY(XK_KP_Subtract, REDKEY_PAD_MINUS);
+    INIT_KEY(XK_KP_4, REDKEY_PAD_4);
+    INIT_KEY(XK_KP_Left, REDKEY_PAD_4);
+    INIT_KEY(XK_KP_5, REDKEY_PAD_5);
+    INIT_KEY(XK_KP_Begin, REDKEY_PAD_5);
+    INIT_KEY(XK_KP_6, REDKEY_PAD_6);
+    INIT_KEY(XK_KP_Right, REDKEY_PAD_6);
+    INIT_KEY(XK_KP_Add, REDKEY_PAD_PLUS);
+    INIT_KEY(XK_KP_1, REDKEY_PAD_1);
+    INIT_KEY(XK_KP_End, REDKEY_PAD_1);
+    INIT_KEY(XK_KP_2, REDKEY_PAD_2);
+    INIT_KEY(XK_KP_Down, REDKEY_PAD_2);
+    INIT_KEY(XK_KP_3, REDKEY_PAD_3);
+    INIT_KEY(XK_KP_Page_Down, REDKEY_PAD_3);
+    INIT_KEY(XK_KP_0, REDKEY_PAD_0);
+    INIT_KEY(XK_KP_Insert, REDKEY_PAD_0);
+    INIT_KEY(XK_KP_Decimal, REDKEY_PAD_POINT);
+    INIT_KEY(XK_KP_Delete, REDKEY_PAD_POINT);
+    INIT_KEY(XK_F11, REDKEY_F11);
+    INIT_KEY(XK_F12, REDKEY_F12);
+
+    INIT_KEY(XK_KP_Enter, REDKEY_PAD_ENTER);
+    INIT_KEY(XK_Control_R, REDKEY_R_CTRL);
+    INIT_KEY(XK_KP_Divide, REDKEY_PAD_DIVIDE);
+    INIT_KEY(XK_Print, REDKEY_CTRL_PRINT_SCREEN);
+
+    INIT_KEY(XK_Home, REDKEY_HOME);
+    INIT_KEY(XK_Up, REDKEY_UP);
+    INIT_KEY(XK_Page_Up, REDKEY_PAGEUP);
+    INIT_KEY(XK_Left, REDKEY_LEFT);
+    INIT_KEY(XK_Right, REDKEY_RIGHT);
+    INIT_KEY(XK_End, REDKEY_END);
+
+    INIT_KEY(XK_Down, REDKEY_DOWN);
+    INIT_KEY(XK_Page_Down, REDKEY_PAGEDOWN);
+    INIT_KEY(XK_Insert, REDKEY_INSERT);
+    INIT_KEY(XK_Delete, REDKEY_DELETE);
+    INIT_KEY(XK_Super_L, REDKEY_LEFT_CMD);
+    INIT_KEY(XK_Super_R, REDKEY_RIGHT_CMD);
+    INIT_KEY(XK_Menu, REDKEY_MENU);
+    INIT_KEY(XK_Pause, REDKEY_CTRL_BREAK);
+}
+
+#undef INIT_KEY
+#define INIT_KEY(x, red) key_table_0x00[x & 0xff] = red;
+
+static void init_key_table_0x00()
+{
+    for (int i = 0; i < sizeof(key_table_0x00) / sizeof(key_table_0x00[0]); i++) {
+        key_table_0x00[i] = REDKEY_INVALID;
+    }
+
+    INIT_KEY(XK_1, REDKEY_1);
+    INIT_KEY(XK_2, REDKEY_2);
+    INIT_KEY(XK_3, REDKEY_3);
+    INIT_KEY(XK_4, REDKEY_4);
+    INIT_KEY(XK_5, REDKEY_5);
+    INIT_KEY(XK_6, REDKEY_6);
+    INIT_KEY(XK_7, REDKEY_7);
+    INIT_KEY(XK_8, REDKEY_8);
+    INIT_KEY(XK_9, REDKEY_9);
+    INIT_KEY(XK_0, REDKEY_0);
+    INIT_KEY(XK_minus, REDKEY_MINUS);
+    INIT_KEY(XK_equal, REDKEY_EQUALS);
+    INIT_KEY(XK_q, REDKEY_Q);
+    INIT_KEY(XK_w, REDKEY_W);
+    INIT_KEY(XK_e, REDKEY_E);
+    INIT_KEY(XK_r, REDKEY_R);
+    INIT_KEY(XK_t, REDKEY_T);
+    INIT_KEY(XK_y, REDKEY_Y);
+    INIT_KEY(XK_u, REDKEY_U);
+    INIT_KEY(XK_i, REDKEY_I);
+    INIT_KEY(XK_o, REDKEY_O);
+    INIT_KEY(XK_p, REDKEY_P);
+    INIT_KEY(XK_bracketleft, REDKEY_L_BRACKET);
+    INIT_KEY(XK_bracketright, REDKEY_R_BRACKET);
+    INIT_KEY(XK_a, REDKEY_A);
+    INIT_KEY(XK_s, REDKEY_S);
+    INIT_KEY(XK_e, REDKEY_E);
+    INIT_KEY(XK_d, REDKEY_D);
+    INIT_KEY(XK_f, REDKEY_F);
+    INIT_KEY(XK_g, REDKEY_G);
+    INIT_KEY(XK_h, REDKEY_H);
+    INIT_KEY(XK_j, REDKEY_J);
+    INIT_KEY(XK_k, REDKEY_K);
+    INIT_KEY(XK_l, REDKEY_L);
+    INIT_KEY(XK_semicolon, REDKEY_SEMICOLON);
+    INIT_KEY(XK_quoteright, REDKEY_QUOTE);
+    INIT_KEY(XK_quoteleft, REDKEY_BACK_QUOTE);
+    INIT_KEY(XK_backslash, REDKEY_BACK_SLASH);
+    INIT_KEY(XK_z, REDKEY_Z);
+    INIT_KEY(XK_x, REDKEY_X);
+    INIT_KEY(XK_c, REDKEY_C);
+    INIT_KEY(XK_v, REDKEY_V);
+    INIT_KEY(XK_b, REDKEY_B);
+    INIT_KEY(XK_n, REDKEY_N);
+    INIT_KEY(XK_m, REDKEY_M);
+    INIT_KEY(XK_comma, REDKEY_COMMA);
+    INIT_KEY(XK_period, REDKEY_PERIOD);
+    INIT_KEY(XK_slash, REDKEY_SLASH);
+    INIT_KEY(XK_space, REDKEY_SPACE);
+}
+
+#undef INIT_KEY
+#define INIT_KEY(x, red) key_table_0xfe[x & 0xff] = red;
+
+static void init_key_table_0xfe()
+{
+    for (int i = 0; i < sizeof(key_table_0xfe) / sizeof(key_table_0xfe[0]); i++) {
+        key_table_0xfe[i] = REDKEY_INVALID;
+    }
+
+    INIT_KEY(XK_ISO_Level3_Shift, REDKEY_R_ALT);
+}
+
+static inline RedKey to_red_key_code(unsigned int keycode)
+{
+    KeySym sym = XKeycodeToKeysym(x_display, keycode, 0);
+    RedKey red_key;
+
+    if (sym == NoSymbol) {
+        DBG(0, "no symbol for %d", keycode);
+    }
+
+    switch (sym >> 8) {
+    case 0x00:
+        red_key = key_table_0x00[sym & 0xff];
+        break;
+    case 0xff:
+        red_key = key_table_0xff[sym & 0xff];
+        break;
+    case 0xfe:
+        red_key = key_table_0xfe[sym & 0xff];
+        break;
+    default:
+        DBG(0, "unsupported key set %lu", (sym >> 8));
+        return REDKEY_INVALID;
+    }
+
+    if (red_key == REDKEY_INVALID) {
+        DBG(0, "no valid key mapping for keycode %u", keycode);
+    }
+    return red_key;
+}
+
+#endif
+
+static inline int to_red_buttons_state(unsigned int state)
+{
+    return ((state & Button1Mask) ? REDC_LBUTTON_MASK : 0) |
+           ((state & Button2Mask) ? REDC_MBUTTON_MASK : 0) |
+           ((state & Button3Mask) ? REDC_RBUTTON_MASK : 0);
+}
+
+static inline RedButton to_red_button(unsigned int botton, unsigned int& state, bool press)
+{
+    unsigned int mask = 0;
+    RedButton ret;
+
+    switch (botton) {
+    case Button1:
+        mask = REDC_LBUTTON_MASK;
+        ret = REDC_MOUSE_LBUTTON;
+        break;
+    case Button2:
+        mask = REDC_MBUTTON_MASK;
+        ret = REDC_MOUSE_MBUTTON;
+        break;
+    case Button3:
+        mask = REDC_RBUTTON_MASK;
+        ret = REDC_MOUSE_RBUTTON;
+        break;
+    case Button4:
+        ret = REDC_MOUSE_UBUTTON;
+        break;
+    case Button5:
+        ret = REDC_MOUSE_DBUTTON;
+        break;
+    default:
+        ret = REDC_MOUSE_INVALID_BUTTON;
+    }
+    if (press) {
+        state |= mask;
+    } else {
+        state &= ~mask;
+    }
+    return ret;
+}
+
+void RedWindow_p::win_proc(XEvent& event)
+{
+    XPointer window_pointer;
+    RedWindow* red_window;
+
+    if (XFindContext(x_display, event.xany.window, user_data_context, &window_pointer)) {
+        THROW("no user data");
+    }
+    red_window = (RedWindow*)window_pointer;
+    switch (event.type) {
+    case MotionNotify: {
+        Point size = red_window->get_size();
+        if (event.xmotion.x >= 0 && event.xmotion.y >= 0 &&
+            event.xmotion.x < size.x && event.xmotion.y < size.y) {
+            Point origin = red_window->get_origin();
+            red_window->get_listener().on_mouse_motion(event.xmotion.x - origin.x,
+                                                       event.xmotion.y - origin.y,
+                                                       to_red_buttons_state(event.xmotion.state));
+        }
+        break;
+    }
+    case KeyPress:
+        red_window->get_listener().on_key_press(to_red_key_code(event.xkey.keycode));
+        break;
+    case KeyRelease: {
+        RedKey key = to_red_key_code(event.xkey.keycode);
+        if (key != REDKEY_KOREAN_HANGUL && key != REDKEY_KOREAN_HANGUL_HANJA) {
+            red_window->get_listener().on_key_release(key);
+        }
+        break;
+    }
+    case ButtonPress: {
+        unsigned int state = to_red_buttons_state(event.xbutton.state);
+        RedButton button = to_red_button(event.xbutton.button, state, true);
+        if (button == REDC_MOUSE_INVALID_BUTTON) {
+            DBG(0, "ButtonPress: invalid button %u", event.xbutton.button);
+            break;
+        }
+        red_window->get_listener().on_button_press(button, state);
+        break;
+    }
+    case ButtonRelease: {
+        unsigned int state = to_red_buttons_state(event.xbutton.state);
+        RedButton button = to_red_button(event.xbutton.button, state, false);
+        if (button == REDC_MOUSE_INVALID_BUTTON) {
+            DBG(0, "ButtonRelease: invalid button %u", event.xbutton.button);
+            break;
+        }
+        red_window->get_listener().on_button_release(button, state);
+        break;
+    }
+    case Expose: {
+        Point origin;
+        Rect area;
+
+        origin = red_window->get_origin();
+        area.left = event.xexpose.x - origin.x;
+        area.right = area.left + event.xexpose.width;
+        area.top = event.xexpose.y - origin.y;
+        area.bottom = area.top + event.xexpose.height;
+        red_window->get_listener().on_exposed_rect(area);
+        break;
+    }
+    case FocusIn:
+        if (!red_window->_ignore_foucs) {
+            red_window->on_focus_in();
+        } else {
+            red_window->_shadow_foucs_state = true;
+        }
+        break;
+    case FocusOut:
+        if (! red_window->_ignore_foucs) {
+            red_window->on_focus_out();
+        } else {
+            red_window->_shadow_foucs_state = false;
+        }
+        break;
+    case ConfigureNotify:
+        break;
+    case ClientMessage:
+        if (event.xclient.message_type == wm_protocol_atom) {
+            ASSERT(event.xclient.format == 32);
+            if (event.xclient.data.l[0] == wm_delete_window_atom) {
+                DBG(0, "wm_delete_window");
+                Platform::send_quit_request();
+            }
+        }
+        break;
+    case DestroyNotify:
+        break;
+    case MapNotify:
+        red_window->set_visibale(true);
+        break;
+    case UnmapNotify:
+        red_window->set_visibale(false);
+        break;
+    case EnterNotify:
+        red_window->on_pointer_enter();
+        break;
+    case LeaveNotify:
+        red_window->on_pointer_leave();
+        break;
+    }
+}
+
+void RedWindow_p::sync()
+{
+    XSync(x_display, False);
+    XEvent event;
+    while (XCheckWindowEvent(x_display, _win, ~long(0), &event)) {
+        win_proc(event);
+    }
+}
+
+void RedWindow_p::wait_for_reparent()
+{
+    XEvent event;
+    for (int i = 0; i < 50; i++) {
+        if (XCheckTypedWindowEvent(x_display, _win, ReparentNotify, &event)) {
+            return;
+        }
+        usleep(20 * 1000);
+        XSync(x_display, False);
+    }
+    DBG(0, "failed");
+}
+
+void RedWindow_p::wait_for_map()
+{
+    bool wait_parent = _expect_parent;
+    while (!_visibale) {
+        XEvent event;
+        XWindowEvent(x_display, _win, ~0, &event);
+        switch (event.type) {
+        case ReparentNotify:
+            wait_parent = false;
+            break;
+        case MapNotify:
+            _visibale = true;
+            break;
+        default:
+            //todo: post state messages to app message queue instead of
+            //      calling win_proc
+            win_proc(event);
+        }
+    }
+
+    if (wait_parent) {
+        wait_for_reparent();
+    }
+}
+
+void RedWindow_p::wait_for_unmap()
+{
+    bool wait_parent = _expect_parent;
+    while (_visibale) {
+        XEvent event;
+        XWindowEvent(x_display, _win, ~0, &event);
+        switch (event.type) {
+        case ReparentNotify:
+            wait_parent = false;
+            break;
+        case UnmapNotify:
+            _visibale = false;
+            break;
+        //default:
+        //    win_proc(event);
+        }
+    }
+
+    if (wait_parent) {
+        wait_for_reparent();
+    }
+}
+
+void RedWindow_p::set_glx(int width, int height)
+{
+    if (_glcont_copy) {
+        XSync(x_display, False);
+        glXMakeCurrent(x_display, _win, _glcont_copy);
+        //glDrawBuffer(GL_FRONT);
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        gluOrtho2D(0, width, 0, height);
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        glViewport(0, 0, width, height);
+        glColor3f(1, 1, 1);
+        glEnable(GL_TEXTURE_2D);
+        GLC_ERROR_TEST_FINISH;
+    }
+}
+
+void RedWindow_p::set_minmax(PixelsSource_p& pix_source, int width, int height)
+{
+    //todo: auto res
+    XSizeHints* size_hints = XAllocSizeHints();
+    ASSERT(size_hints);
+    size_hints->flags = PMinSize | PMaxSize;
+    size_hints->min_width = size_hints->max_width = width;
+    size_hints->min_height = size_hints->max_height = height;
+    XSetWMNormalHints(x_display, _win, size_hints);
+    XFree(size_hints);
+    pix_source.x_drawable.height = height;
+    pix_source.x_drawable.width = width;
+}
+
+Cursor RedWindow_p::create_invisible_cursor(Window window)
+{
+    XColor color;
+    char data[1] = {0};
+    Window root_window = RootWindow(x_display, DefaultScreen(x_display));
+    Pixmap blank = XCreateBitmapFromData(x_display, root_window, data, 1, 1);
+    Cursor cursor = XCreatePixmapCursor(x_display, blank, blank, &color, &color, 0, 0);
+    XFreePixmap(x_display, blank);
+    return cursor;
+}
+
+RedWindow_p::RedWindow_p()
+    : _win (None)
+    , _glcont_copy (NULL)
+    , _icon (NULL)
+    , _ignore_foucs (false)
+{
+}
+
+void RedWindow_p::destroy(PixelsSource_p& pix_source)
+{
+    if (_win == None) {
+        return;
+    }
+    XPlatform::cleare_win_proc(_win);
+    XSelectInput(x_display, _win, 0);
+    XSync(x_display, False);
+    XEvent event;
+    while (XCheckWindowEvent(x_display, _win, ~long(0), &event));
+    Window window = _win;
+    _win = None;
+    XFreeCursor(x_display, _invisible_cursor);
+    _invisible_cursor = None;
+    XDeleteContext(x_display, window, user_data_context);
+    if (_glcont_copy) {
+        glXDestroyContext(x_display, _glcont_copy);
+        _glcont_copy = NULL;
+    }
+    XDestroyWindow(x_display, window);
+    XFreeGC(x_display, pix_source.x_drawable.gc);
+    pix_source.x_drawable.gc = NULL;
+    pix_source.x_drawable.drawable = None;
+    if (_icon) {
+        _icon->unref();
+    }
+}
+
+void RedWindow_p::create(RedWindow& red_window, PixelsSource_p& pix_source, int x, int y,
+                         unsigned int width, unsigned int height, int in_screen)
+{
+    Window window = None;
+    Cursor cursor = None;
+    GC gc = NULL;
+
+    Window root_window = RootWindow(x_display, in_screen);
+    XSetWindowAttributes win_attributes;
+
+    unsigned long mask = CWBorderPixel | CWEventMask;
+    win_attributes.border_pixel = 1;
+    win_attributes.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask |
+                                KeyPressMask | KeyReleaseMask | ButtonPressMask |
+                                ButtonReleaseMask | PointerMotionMask | FocusChangeMask |
+                                EnterWindowMask | LeaveWindowMask;
+
+    Colormap colormap;
+
+    colormap = XCreateColormap(x_display, root_window, XPlatform::get_vinfo()[in_screen]->visual,
+                               AllocNone);
+    win_attributes.colormap = colormap;
+    mask |= CWColormap;
+    window = XCreateWindow(x_display, root_window, x, y,
+                           width, height, 0, XPlatform::get_vinfo()[in_screen]->depth,
+                           InputOutput, XPlatform::get_vinfo()[in_screen]->visual, mask,
+                           &win_attributes);
+    XFreeColormap(x_display, colormap);
+
+    if (!window) {
+        THROW("create X window failed");
+    }
+
+    try {
+        if (XSaveContext(x_display, window, user_data_context, (XPointer)&red_window)) {
+            THROW("set win usr data failed");
+        }
+
+        XSetWMProtocols(x_display, window, &wm_delete_window_atom, 1);
+        XGCValues gc_vals;
+        if (!(gc = XCreateGC(x_display, window, 0, &gc_vals))) {
+            THROW("create gc failed");
+        }
+        if (!(cursor = create_invisible_cursor(window))) {
+            THROW("create invisible cursor failed");
+        }
+
+        XPlatform::set_win_proc(window, win_proc);
+    } catch (...) {
+        if (gc) {
+            XFreeGC(x_display, gc);
+        }
+
+        XDeleteContext(x_display, window, user_data_context);
+        XDestroyWindow(x_display, window);
+        if (cursor != None) {
+            XFreeCursor(x_display, cursor);
+        }
+
+        throw;
+    }
+    _screen = in_screen;
+    _win = window;
+    _invisible_cursor = cursor;
+    _show_pos.x = x;
+    _show_pos.y = y;
+    _visibale = false;
+    _expect_parent = false;
+    pix_source.type = PIXELS_SOURCE_TYPE_X_DRAWABLE;
+    pix_source.x_drawable.drawable = window;
+    pix_source.x_drawable.gc = gc;
+    set_minmax(pix_source, width, height);
+    sync();
+}
+
+void RedWindow_p::migrate(RedWindow& red_window, PixelsSource_p& pix_source, int to_screen)
+{
+    if (to_screen == _screen) {
+        return;
+    }
+    XWindowAttributes attrib;
+    if (!XGetWindowAttributes(x_display, _win, &attrib)) {
+        THROW("get attributes failed");
+    }
+    XTextProperty text_pro;
+    bool valid_title = XGetWMName(x_display, _win, &text_pro) && text_pro.value;
+    destroy(pix_source);
+    create(red_window, pix_source, _show_pos.x, _show_pos.y, attrib.width, attrib.height,
+           to_screen);
+    if (valid_title) {
+        XSetWMName(x_display, _win, &text_pro);
+        XFree(text_pro.value); //???
+    }
+    if (_icon) {
+        AutoRef<Icon> red(_icon->ref());
+        red_window.set_icon(_icon);
+    }
+}
+
+void RedWindow_p::move_to_current_desktop()
+{
+    Window root = RootWindow(x_display, _screen);
+    Atom actual_type_return;
+    int actual_format_return;
+    unsigned long bytes_after_return;
+    unsigned long nitems_return;
+    unsigned char *prop_return;
+    long desktop = ~long(0);
+
+    if (XGetWindowProperty(x_display, root, wm_current_desktop, 0, 1, False, AnyPropertyType,
+                           &actual_type_return, &actual_format_return, &nitems_return,
+                           &bytes_after_return, &prop_return) == Success &&
+                                         actual_type_return != None && actual_format_return == 32) {
+        desktop = *(uint32_t *)prop_return;
+    } else {
+        DBG(0, "get current desktop failed");
+    }
+
+    XEvent xevent;
+    xevent.type = ClientMessage;
+    xevent.xclient.window = _win;
+    xevent.xclient.message_type = wm_desktop;
+    xevent.xclient.format = 32;
+    xevent.xclient.data.l[0] = desktop;
+    xevent.xclient.data.l[1] = 0;
+    xevent.xclient.data.l[2] = 0;
+    xevent.xclient.data.l[3] = 0;
+    xevent.xclient.data.l[4] = 0;
+    if (!XSendEvent(x_display, root, False, SubstructureNotifyMask | SubstructureRedirectMask,
+                    &xevent)) {
+        DBG(0, "failed");
+    }
+}
+
+RedWindow::RedWindow(RedWindow::Listener& listener, int screen)
+    : _listener (listener)
+    , _type (TYPE_NORMAL)
+    , _local_cursor (NULL)
+    , _cursor_visible (true)
+    , _focused (false)
+    , _pointer_in_window (false)
+    , _key_interception (false)
+    , _menu (NULL)
+{
+    ASSERT(x_display);
+    create(*this, *(PixelsSource_p*)get_opaque(), 0, 0, 200, 200,
+           (screen == DEFAULT_SCREEN) ? DefaultScreen(x_display) : screen);
+}
+
+RedWindow::~RedWindow()
+{
+    destroy(*(PixelsSource_p*)get_opaque());
+    if (_local_cursor) {
+        _local_cursor->unref();
+    }
+}
+
+void RedWindow::set_title(std::wstring& title)
+{
+    XTextProperty text_prop;
+    wchar_t *name = const_cast<wchar_t *>(title.c_str());
+    int r;
+    if (_win) {
+        r = XwcTextListToTextProperty(x_display, &name, 1, XStringStyle, &text_prop);
+        if (r >= 0) {
+            XSetWMName(x_display, _win, &text_prop);
+            XFree(text_prop.value);
+        } else {
+            LOG_WARN("XwcTextListToTextProperty Error %d", r);
+        }
+    }
+}
+
+void RedWindow::set_icon(Icon* icon)
+{
+    if (_icon) {
+        _icon->unref();
+        _icon = NULL;
+    }
+    if (!icon) {
+        return;
+    }
+    _icon = icon->ref();
+
+    XWMHints* wm_hints;
+    if (_win == None || !(wm_hints = XAllocWMHints())) {
+        return;
+    }
+
+    try {
+        XIcon* xicon = (XIcon*)icon;
+        xicon->get_pixmaps(_screen, wm_hints->icon_pixmap, wm_hints->icon_mask);
+        wm_hints->flags = IconPixmapHint | IconMaskHint;
+        XSetWMHints(x_display, _win, wm_hints);
+    } catch (...) {
+    }
+    XFree(wm_hints);
+}
+
+static XErrorHandler old_error_handler = NULL;
+static unsigned char x_error = Success;
+
+static int x_error_handler(Display* display, XErrorEvent* error_event)
+{
+    x_error = error_event->error_code;
+    if (error_event->error_code == BadWindow) {
+        return 0;
+    }
+    ASSERT(old_error_handler);
+    XSetErrorHandler(old_error_handler);
+    old_error_handler(display, error_event);
+    old_error_handler = NULL;
+    return 0;
+}
+
+class AutoXErrorHandler {
+public:
+    AutoXErrorHandler()
+    {
+        ASSERT(old_error_handler == NULL);
+        XSync(x_display, False);
+        x_error = Success;
+        old_error_handler = XSetErrorHandler(x_error_handler);
+    }
+
+    ~AutoXErrorHandler()
+    {
+        if (old_error_handler) {
+            XSetErrorHandler(old_error_handler);
+            old_error_handler = NULL;
+        }
+    }
+};
+
+static Window get_window_for_reposition(Window window)
+{
+    for (;;) {
+        Window root;
+        Window parent;
+        Window* childrens;
+        unsigned int num_childrens;
+
+        if (!XQueryTree(x_display, window, &root, &parent, &childrens, &num_childrens)) {
+            return None;
+        }
+
+        if (childrens) {
+            XFree(childrens);
+        }
+
+        if (parent == root) {
+            break;
+        }
+        window = parent;
+    }
+    return window;
+}
+
+void RedWindow::raise()
+{
+    AutoXErrorHandler auto_error_handler;
+    int raise_retries = RAISE_RETRIES;
+    for (;; --raise_retries) {
+        Window window = get_window_for_reposition(_win);
+        if (window != None) {
+            x_error = Success;
+            XRaiseWindow(x_display, window);
+            if (x_error == Success) {
+                break;
+            }
+            if (x_error != BadWindow) {
+                THROW("XRaiseWindow failed");
+            }
+        }
+
+        if (!raise_retries) {
+            THROW("failed");
+        }
+        usleep(X_RETRY_DELAY_MICRO);
+    }
+    if (raise_retries < RAISE_RETRIES) {
+        DBG(0, "retries %d", (RAISE_RETRIES - raise_retries));
+    }
+    sync();
+}
+
+void RedWindow::position_after(RedWindow *after)
+{
+    if (!after || after->_screen != _screen) {
+        raise();
+        return;
+    }
+
+    AutoXErrorHandler auto_error_handler;
+    int position_retries = Z_POSITION_RETRIES;
+    for (;; --position_retries) {
+        Window sibling = get_window_for_reposition(after->get_window());
+        Window self = get_window_for_reposition(_win);
+        if (sibling != None && self != None) {
+            XWindowChanges changes;
+            changes.sibling = sibling;
+            changes.stack_mode = Below;
+            x_error = Success;
+            XConfigureWindow(x_display, self, CWSibling | CWStackMode, &changes);
+            if (x_error == Success) {
+                break;
+            }
+            if (x_error != BadWindow) {
+                THROW("XConfigureWindow failed");
+            }
+        }
+
+        if (!position_retries) {
+            THROW("failed");
+        }
+        usleep(X_RETRY_DELAY_MICRO);
+    }
+    if (position_retries < Z_POSITION_RETRIES) {
+        DBG(0, "retries %d", (Z_POSITION_RETRIES - position_retries));
+    }
+}
+
+void RedWindow::show(int screen_id)
+{
+    if (_visibale) {
+        return;
+    }
+
+    bool wait_parent;
+
+    if (screen_id != _screen) {
+        _listener.pre_migrate();
+        migrate(*this, *(PixelsSource_p*)get_opaque(), screen_id);
+        _listener.post_migrate();
+    }
+
+    if (_type == TYPE_FULLSCREEN) {
+        Atom state[2];
+        state[0] = wm_state_above;
+        state[1] = wm_state_fullscreen;
+        XChangeProperty(x_display, _win, wm_state, XA_ATOM, 32, PropModeReplace,
+                        (unsigned char*)state, 2);
+        wait_parent = false;
+    } else {
+        XDeleteProperty(x_display, _win, wm_state);
+        wait_parent = true;
+    }
+    XMapWindow(x_display, _win);
+    move_to_current_desktop();
+    _expect_parent = wait_parent;
+    wait_for_map();
+    move(_show_pos.x, _show_pos.y);
+}
+
+static bool get_prop_32(Window win, Atom prop, uint32_t &val)
+{
+    Atom actual_type_return;
+    int actual_format_return;
+    unsigned long bytes_after_return;
+    unsigned long nitems_return;
+    unsigned char *prop_return;
+
+    if (XGetWindowProperty(x_display, win, prop, 0, 1, False, AnyPropertyType,
+                           &actual_type_return, &actual_format_return,
+                           &nitems_return, &bytes_after_return, &prop_return) == Success &&
+                                                            nitems_return == 1 &&
+                                                            actual_type_return != None &&
+                                                            actual_format_return == 32) {
+        val = *(uint32_t *)prop_return;
+        return true;
+    }
+    return false;
+}
+
+void RedWindow::external_show()
+{
+    Atom atom;
+
+    DBG(0, "");
+    show(_screen);
+    raise();
+    activate();
+
+    atom = XInternAtom(x_display, "_NET_ACTIVE_WINDOW", true);
+    if (atom != None) {
+        Window root;
+        XEvent xev;
+        long eventmask;
+
+        xev.xclient.type = ClientMessage;
+        xev.xclient.serial = 0;
+        xev.xclient.send_event = True;
+        xev.xclient.window = _win;
+        xev.xclient.message_type = atom;
+
+        xev.xclient.format = 32;
+        xev.xclient.data.l[0] = 1;
+
+        uint32_t user_time;
+        if (get_prop_32(_win, wm_user_time, user_time)) {
+            xev.xclient.data.l[1] = user_time;
+        } else {
+            xev.xclient.data.l[1] = 0;
+        }
+        xev.xclient.data.l[2] = 0;
+        xev.xclient.data.l[3] = 0;
+        xev.xclient.data.l[4] = 0;
+
+        root = RootWindow(x_display, _screen),
+        eventmask = SubstructureRedirectMask | SubstructureNotifyMask;
+
+        XSendEvent(x_display, root, False, eventmask, &xev);
+    }
+}
+
+void RedWindow::hide()
+{
+    if (!_visibale) {
+        return;
+    }
+    on_pointer_leave();
+    on_focus_out();
+    XUnmapWindow(x_display, _win);
+    _show_pos = get_position();
+    wait_for_unmap();
+    ASSERT(!_focused);
+    ASSERT(!_pointer_in_window);
+    _expect_parent = false;
+}
+
+static void send_expose(Window window, int width, int height)
+{
+    XExposeEvent event;
+    event.type = Expose;
+    event.display = x_display;
+    event.window = window;
+    event.x = 0;
+    event.y = 0;
+    event.width = width;
+    event.height = height;
+    event.count = 0;
+    XSendEvent(x_display, window, False, ExposureMask, (XEvent *)&event);
+}
+
+void RedWindow::move_and_resize(int x, int y, int width, int height)
+{
+    set_minmax(*(PixelsSource_p*)get_opaque(), width, height);
+    XMoveResizeWindow(x_display, _win, x, y, width, height);
+    _show_pos.x = x;
+    _show_pos.y = y;
+    if (_visibale) {
+        send_expose(_win, width, height);
+    }
+}
+
+void RedWindow::move(int x, int y)
+{
+    XMoveWindow(x_display, _win, x, y);
+    _show_pos.x = x;
+    _show_pos.y = y;
+}
+
+void RedWindow::resize(int width, int height)
+{
+    set_minmax(*(PixelsSource_p*)get_opaque(), width, height);
+    XResizeWindow(x_display, _win, width, height);
+    if (_visibale) {
+        send_expose(_win, width, height);
+    }
+}
+
+void RedWindow::activate()
+{
+    //todo: use _NET_ACTIVE_WINDOW
+    XSetInputFocus(x_display, _win, RevertToParent, CurrentTime);
+}
+
+void RedWindow::minimize()
+{
+    XIconifyWindow(x_display, _win, _screen);
+    sync();
+}
+
+static bool __get_position(Window window, Point& pos)
+{
+    pos.x = pos.y = 0;
+    for (;;) {
+        XWindowAttributes attrib;
+        Window root;
+        Window parent;
+        Window* childrens;
+        unsigned int num_childrens;
+
+        if (!XGetWindowAttributes(x_display, window, &attrib)) {
+            return false;
+        }
+        pos.x += attrib.x;
+        pos.y += attrib.y;
+
+        if (!XQueryTree(x_display, window, &root, &parent, &childrens, &num_childrens)) {
+            return false;
+        }
+
+        if (childrens) {
+            XFree(childrens);
+        }
+
+        if (parent == None) {
+            break;
+        }
+        window = parent;
+    }
+    return true;
+}
+
+Point RedWindow::get_position()
+{
+    Point pos;
+
+    AutoXErrorHandler auto_error_handler;
+    int get_position_retries = GET_POSITION_RETRIES;
+    for (;; --get_position_retries) {
+        if (__get_position(_win, pos)) {
+            break;
+        }
+        if (!get_position_retries) {
+            THROW("failed");
+        }
+        usleep(X_RETRY_DELAY_MICRO);
+    }
+
+    if (get_position_retries < GET_POSITION_RETRIES) {
+        DBG(0, "retries %d", (GET_POSITION_RETRIES - get_position_retries));
+    }
+    return pos;
+}
+
+void RedWindow::do_start_key_interception()
+{
+    // Working with KDE: XGrabKeyboard generate focusout and focusin events
+    // while we have the focus. This behavior trigger infinite recursive. for
+    // that reason we temporary disable focus event handling.
+
+    ASSERT(_focused);
+    _ignore_foucs = true;
+    _shadow_foucs_state = true;
+    XGrabKeyboard(x_display, _win, True, GrabModeAsync, GrabModeAsync, CurrentTime);
+    sync();
+    _listener.on_start_key_interception();
+    _ignore_foucs = false;
+    if (!_shadow_foucs_state) {
+        on_focus_out();
+    }
+}
+
+void RedWindow::do_stop_key_interception()
+{
+    XUngrabKeyboard(x_display, CurrentTime);
+    sync();
+    _listener.on_stop_key_interception();
+}
+
+void RedWindow::start_key_interception()
+{
+    if (_key_interception) {
+        return;
+    }
+    _key_interception = true;
+    if (_pointer_in_window && _focused) {
+        do_start_key_interception();
+    }
+}
+
+void RedWindow::stop_key_interception()
+{
+    if (!_key_interception) {
+        return;
+    }
+    _key_interception = false;
+    if (_focused && _pointer_in_window) {
+        do_stop_key_interception();
+    }
+}
+
+void RedWindow::set_cursor(LocalCursor* local_cursor)
+{
+    ASSERT(local_cursor);
+    if (_local_cursor) {
+        _local_cursor->unref();
+    }
+    _local_cursor = local_cursor->ref();
+    _local_cursor->set(_win);
+    _cursor_visible = true;
+}
+
+void RedWindow::show_cursor()
+{
+    if (!_cursor_visible) {
+        if (_local_cursor) {
+            _local_cursor->set(_win);
+        }
+        _cursor_visible = true;
+    }
+}
+
+void RedWindow::hide_cursor()
+{
+    if (_cursor_visible) {
+        XDefineCursor(x_display, _win, _invisible_cursor);
+        _cursor_visible = false;
+    }
+}
+
+void RedWindow::release_mouse()
+{
+    XUngrabPointer(x_display, CurrentTime);
+    sync();
+}
+
+void RedWindow::cupture_mouse()
+{
+    int grab_retries = MOUSE_GRAB_RETRIES;
+    XSync(x_display, False);
+    for (;; --grab_retries) {
+        int result = XGrabPointer(x_display, _win, True, 0,
+                                  GrabModeAsync, GrabModeAsync,
+                                  _win, None, CurrentTime);
+        if (result == GrabSuccess) {
+            break;
+        }
+
+        if (!grab_retries) {
+            THROW("grab pointer failed (%d)", result);
+        }
+        usleep(X_RETRY_DELAY_MICRO);
+        DBG(0, "grab failed result=%d", result);
+    }
+    sync();
+}
+
+void RedWindow::set_mouse_position(int x, int y)
+{
+    XWarpPointer(x_display, None, _win, 0, 0, 0, 0, x + get_origin().x, y + get_origin().y);
+}
+
+Point RedWindow::get_size()
+{
+    XWindowAttributes attrib;
+    XGetWindowAttributes(x_display, _win, &attrib);
+    Point size;
+    size.x = attrib.width;
+    size.y = attrib.height;
+    return size;
+}
+
+static void window_area_from_attributes(Rect& area, XWindowAttributes& attrib)
+{
+    area.left = attrib.x;
+    area.right = area.left + attrib.width;
+    area.top = attrib.y;
+    area.bottom = area.top + attrib.height;
+}
+
+#define FAIL_ON_BAD_WINDOW(error, format, ...)              \
+    if (error) {                                            \
+        if ((x_error) == BadWindow) {                       \
+            return NULL;                                    \
+        }                                                   \
+        THROW(format, ## __VA_ARGS__);                      \
+    }
+
+
+static QRegion *get_visibale_region(Window window)
+{
+    QRegion* region = new QRegion;
+    region_init(region);
+    XWindowAttributes attrib;
+    if (!XGetWindowAttributes(x_display, window, &attrib)) {
+        return NULL;
+    }
+
+    if (attrib.map_state != IsViewable) {
+        DBG(0, "not viewable");
+        return region;
+    }
+
+    Rect window_area;
+    window_area_from_attributes(window_area, attrib);
+    window_area.right -= window_area.left;
+    window_area.bottom -= window_area.top;
+    window_area.top = window_area.left = 0;
+    region_add(region, &window_area);
+    Window prev = None;
+    Window root;
+    Window parent;
+    Window* childrens;
+    unsigned int num_childrens;
+
+    AutoXErrorHandler auto_error_handler;
+    for (;;) {
+        FAIL_ON_BAD_WINDOW(!XQueryTree(x_display, window, &root, &parent, &childrens,
+                                       &num_childrens),
+                           "%s: query X tree failed", __FUNCTION__);
+        for (int i = num_childrens - 1; i >= 0 && childrens[i] != prev; i--) {
+            FAIL_ON_BAD_WINDOW(!XGetWindowAttributes(x_display, childrens[i], &attrib),
+                               "%s: get win attributes failed", __FUNCTION__);
+
+            if (attrib.map_state == IsViewable) {
+                window_area_from_attributes(window_area, attrib);
+                window_area.left -= attrib.border_width;
+                window_area.right += attrib.border_width;
+                window_area.top -= attrib.border_width;
+                window_area.bottom += attrib.border_width;
+                region_remove(region, &window_area);
+            }
+        }
+
+        if (childrens) {
+            XFree(childrens);
+        }
+
+        FAIL_ON_BAD_WINDOW(!XGetWindowAttributes(x_display, window, &attrib),
+                           "%s: get win attributes failed", __FUNCTION__);
+        window_area_from_attributes(window_area, attrib);
+        region_offset(region, window_area.left, window_area.top);
+
+        if (parent == None) {
+            break;
+        }
+
+        FAIL_ON_BAD_WINDOW(!XGetWindowAttributes(x_display, parent, &attrib),
+                           "%s: get win attributes failed", __FUNCTION__);
+        window_area_from_attributes(window_area, attrib);
+        window_area.right -= window_area.left;
+        window_area.bottom -= window_area.top;
+        window_area.top = window_area.left = 0;
+
+        QRegion parent_region;
+        region_init(&parent_region);
+        region_add(&parent_region, &window_area);
+        region_and(region, &parent_region);
+        region_destroy(&parent_region);
+
+        prev = window;
+        window = parent;
+    }
+
+    //todo: intersect with monitors
+    return region;
+}
+
+class Region_p {
+public:
+    Region_p(QRegion* region) : _region (region) {}
+    ~Region_p() { delete _region;}
+
+    void get_bbox(Rect& bbox) const
+    {
+        if (region_is_empty(_region)) {
+            bbox.left = bbox.right = bbox.top = bbox.bottom = 0;
+        } else {
+            bbox = _region->bbox;
+        }
+    }
+
+    bool contains_point(int x, int y) const
+    {
+        return region_contains_point(_region, x, y);
+    }
+
+private:
+    QRegion* _region;
+};
+
+bool RedWindow::get_mouse_anchor_point(Point& pt)
+{
+    QRegion* vis_region;
+    int vis_region_retries = GET_VIS_REGION_RETRIES;
+
+    while (!(vis_region = get_visibale_region(_win))) {
+        if (!vis_region_retries) {
+            THROW("get visibale region failed");
+        }
+        --vis_region_retries;
+        usleep(X_RETRY_DELAY_MICRO);
+    }
+
+    if (vis_region_retries < GET_VIS_REGION_RETRIES) {
+        DBG(0, "retries %d", (GET_VIS_REGION_RETRIES - vis_region_retries));
+    }
+
+    Region_p region(vis_region);
+    if (!find_anchor_point(region, pt)) {
+        return false;
+    }
+    Point position = get_position();
+    pt.x -= (position.x + get_origin().x);
+    pt.y -= (position.y + get_origin().y);
+    return true;
+}
+
+RedGlContext RedWindow::create_context_gl()
+{
+    if (XPlatform::get_fbconfig()[_screen]) {
+        return glXCreateContext(x_display, XPlatform::get_vinfo()[_screen], NULL, GL_TRUE);
+    }
+    return NULL;
+}
+
+RedPbuffer RedWindow::create_pbuff(int width, int height)
+{
+    GLXPbuffer pbuff;
+    GLXFBConfig** fb_config;
+
+    int pbuf_attr[] = { GLX_PRESERVED_CONTENTS, True,
+                        GLX_PBUFFER_WIDTH, width,
+                        GLX_PBUFFER_HEIGHT, height,
+                        GLX_LARGEST_PBUFFER, False,
+                        0, 0 };
+
+    fb_config = XPlatform::get_fbconfig();
+    pbuff = glXCreatePbuffer(XPlatform::get_display(), fb_config[_screen][0],
+                             pbuf_attr);
+
+    return pbuff;
+}
+
+void RedWindow::untouch_context()
+{
+    glXMakeCurrent(x_display, 0, 0);
+}
+
+int RedWindow::get_screen_num()
+{
+    return _screen;
+}
+
+void RedWindow::set_type_gl()
+{
+    PixelsSource_p *pix_source = (PixelsSource_p*)get_opaque();
+
+    pix_source->type = PIXELS_SOURCE_TYPE_GL_DRAWABLE;
+}
+
+void RedWindow::unset_type_gl()
+{
+    PixelsSource_p *pix_source = (PixelsSource_p*)get_opaque();
+
+    pix_source->type = PIXELS_SOURCE_TYPE_X_DRAWABLE;
+}
+
+void RedWindow::set_gl_context(RedGlContext context)
+{
+    PixelsSource_p *pix_source = (PixelsSource_p*)get_opaque();
+
+    pix_source->x_drawable.context = context;
+}
+
+void RedWindow::set_render_pbuff(RedPbuffer pbuff)
+{
+    PixelsSource_p *pix_source = (PixelsSource_p*)get_opaque();
+
+    pix_source->x_drawable.rendertype = RENDER_TYPE_PBUFF;
+    pix_source->x_drawable.pbuff = pbuff;
+}
+
+void RedWindow::set_render_fbo(GLuint fbo)
+{
+    PixelsSource_p *pix_source = (PixelsSource_p*)get_opaque();
+
+    pix_source->x_drawable.rendertype = RENDER_TYPE_FBO;
+    pix_source->x_drawable.fbo = fbo;
+}
+
+void RedWindow::on_focus_in()
+{
+    if (_focused) {
+        return;
+    }
+    _focused = true;
+    if (_key_interception && _pointer_in_window) {
+        do_start_key_interception();
+    }
+    XPlatform::on_focus_in();
+    get_listener().on_activate();
+}
+
+void RedWindow::on_focus_out()
+{
+    if (!_focused) {
+        return;
+    }
+    _focused = false;
+    do_stop_key_interception();
+    XPlatform::on_focus_out();
+    get_listener().on_deactivate();
+}
+
+void RedWindow::on_pointer_enter()
+{
+    if (_pointer_in_window) {
+        return;
+    }
+    _pointer_in_window = true;
+    _listener.on_pointer_enter();
+    if (_focused && _key_interception) {
+        do_start_key_interception();
+    }
+}
+
+void RedWindow::on_pointer_leave()
+{
+    if (!_pointer_in_window) {
+        return;
+    }
+    _pointer_in_window = false;
+    _listener.on_pointer_leave();
+    if (_focused && _key_interception) {
+        do_stop_key_interception();
+    }
+}
+
+void RedWindow::set_menu(Menu* menu)
+{
+}
+
+void RedWindow::init()
+{
+    x_display = XPlatform::get_display();
+    ASSERT(x_display);
+    user_data_context = XUniqueContext();
+
+    wm_protocol_atom = XInternAtom(x_display, "WM_PROTOCOLS", False);
+    wm_delete_window_atom = XInternAtom(x_display, "WM_DELETE_WINDOW", False);
+
+    wm_desktop = XInternAtom(x_display, "_NET_WM_DESKTOP", False);
+    wm_current_desktop = XInternAtom(x_display, "_NET_CURRENT_DESKTOP", False);
+
+    wm_state = XInternAtom(x_display, "_NET_WM_STATE", False);
+    wm_state_above = XInternAtom(x_display, "_NET_WM_STATE_ABOVE", False);
+    wm_state_fullscreen = XInternAtom(x_display, "_NET_WM_STATE_FULLSCREEN", False);
+
+    wm_user_time = XInternAtom(x_display, "_NET_WM_USER_TIME", False);
+
+#ifdef USE_X11_KEYCODE
+    init_key_map();
+#else
+    init_key_table_0xff();
+    init_key_table_0x00();
+    init_key_table_0xfe();
+#endif
+}
+
diff --git a/client/x11/red_window_p.h b/client/x11/red_window_p.h
new file mode 100644
index 00000000..02cbdf98
--- /dev/null
+++ b/client/x11/red_window_p.h
@@ -0,0 +1,67 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_WINDOW_P
+#define _H_RED_WINDOW_P
+
+#include <GL/glx.h>
+
+typedef Window Win;
+typedef GLXContext RedGlContext;
+typedef GLXPbuffer RedPbuffer;
+
+class RedWindow;
+class Icon;
+struct PixelsSource_p;
+
+class RedWindow_p {
+public:
+    RedWindow_p();
+
+    void migrate(RedWindow& red_window, PixelsSource_p& pix_source, int dest_screen);
+    void create(RedWindow& red_window, PixelsSource_p& pix_source, int x, int y,
+                unsigned int width, unsigned int height, int in_screen);
+    void destroy(PixelsSource_p& pix_source);
+    void set_minmax(PixelsSource_p& pix_source, int width, int height);
+    void wait_for_reparent();
+    void wait_for_map();
+    void wait_for_unmap();
+    void sync();
+    void set_visibale(bool vis) { _visibale = vis;}
+    void move_to_current_desktop();
+    Window get_window() {return _win;}
+
+    static void win_proc(XEvent& event);
+    static Cursor create_invisible_cursor(Window window);
+
+    void set_glx(int width, int height);
+
+protected:
+    int _screen;
+    Window _win;
+    Cursor _invisible_cursor;
+    bool _visibale;
+    bool _expect_parent;
+    Point _show_pos;
+    GLXContext _glcont_copy;
+    Icon* _icon;
+    bool _ignore_foucs;
+    bool _shadow_foucs_state;
+};
+
+#endif
+
diff --git a/client/x11/res.cpp b/client/x11/res.cpp
new file mode 100644
index 00000000..8f3a5487
--- /dev/null
+++ b/client/x11/res.cpp
@@ -0,0 +1,91 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common.h"
+#include "resource.h"
+
+#include "images/splash_image.c"
+
+static const PixmapHeader splash_image = {
+    (uint8_t *)_splash_image.pixel_data,
+    _splash_image.width,
+    _splash_image.height,
+    _splash_image.width * 4,
+};
+
+#include "images/info_image.c"
+
+static const PixmapHeader info_image = {
+    (uint8_t *)_info_image.pixel_data,
+    _info_image.width,
+    _info_image.height,
+    _info_image.width * 4,
+};
+
+
+typedef struct ResImage {
+    int id;
+    const PixmapHeader* image;
+} ResImage;
+
+static const ResImage res_image_map[] = {
+    { SPLASH_IMAGE_RES_ID, &splash_image},
+    { INFO_IMAGE_RES_ID, &info_image},
+    {0, NULL},
+};
+
+const PixmapHeader *res_get_image(int id)
+{
+    const ResImage *now = res_image_map;
+    for (; now->image; now++) {
+        if (now->id == id) {
+            return now->image;
+        }
+    }
+    return NULL;
+}
+
+#include "images/red_icon.c"
+
+static const IconHeader red_icon = {
+    _red_icon.width,
+    _red_icon.height,
+    (uint8_t *)_red_icon.pixmap,
+    (uint8_t *)_red_icon.mask,
+};
+
+typedef struct ResIcon {
+    int id;
+    const IconHeader* icon;
+} ResIcon;
+
+static const ResIcon res_icon_map[] = {
+    { RED_ICON_RES_ID, &red_icon},
+    {0, NULL},
+};
+
+const IconHeader *res_get_icon(int id)
+{
+    const ResIcon *now = res_icon_map;
+    for (; now->icon; now++) {
+        if (now->id == id) {
+            return now->icon;
+        }
+    }
+    return NULL;
+}
+
diff --git a/client/x11/res.h b/client/x11/res.h
new file mode 100644
index 00000000..39bb1d68
--- /dev/null
+++ b/client/x11/res.h
@@ -0,0 +1,25 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RES
+#define _H_RES
+
+const PixmapHeader *res_get_image(int id);
+const IconHeader *res_get_icon(int id);
+
+#endif
+
diff --git a/client/x11/resource.h b/client/x11/resource.h
new file mode 100644
index 00000000..276c2339
--- /dev/null
+++ b/client/x11/resource.h
@@ -0,0 +1,26 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_RESOURCES
+#define _H_RED_RESOURCES
+
+#define SPLASH_IMAGE_RES_ID 1
+#define INFO_IMAGE_RES_ID 2
+#define RED_ICON_RES_ID 3
+
+#endif
+
diff --git a/client/x11/x_icon.cpp b/client/x11/x_icon.cpp
new file mode 100644
index 00000000..9899e6a6
--- /dev/null
+++ b/client/x11/x_icon.cpp
@@ -0,0 +1,160 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "x_icon.h"
+#include "platform.h"
+#include "x_platform.h"
+#include "res.h"
+#include "utils.h"
+#include "debug.h"
+
+typedef std::map<int, XIcon*> IconsMap;
+static IconsMap res_icons;
+
+XIcon::XIcon(int id, const IconHeader *icon)
+    : _id (id)
+    , _raw_icon (icon)
+{
+    res_icons[id] = this;
+}
+
+XIcon::~XIcon()
+{
+    Display* x_display = XPlatform::get_display();
+    while (!_screen_icons.empty()) {
+        std::map<int, ScreenIcon>::iterator iter = _screen_icons.begin();
+        XFreePixmap(x_display, (*iter).second.pixmap);
+        XFreePixmap(x_display, (*iter).second.mask);
+        _screen_icons.erase(iter);
+    }
+    IconsMap::iterator iter = res_icons.find(_id);
+    res_icons.erase(iter);
+}
+
+void XIcon::get_pixmaps(int screen, Pixmap& out_pixmap, Pixmap& out_mask)
+{
+    std::map<int, ScreenIcon>::iterator iter = _screen_icons.find(screen);
+    if (iter != _screen_icons.end()) {
+        out_pixmap = (*iter).second.pixmap;
+        out_mask = (*iter).second.mask;
+        return;
+    }
+
+    Display* x_display = XPlatform::get_display();
+    Window root_window = RootWindow(x_display, screen);
+
+    Pixmap pixmap = None;
+    Pixmap mask = None;
+    GC gc = NULL;
+    try {
+        pixmap = XCreatePixmap(x_display, root_window, _raw_icon->width, _raw_icon->height, 24);
+        if (pixmap == None) {
+            THROW("create pixmap failed");
+        }
+
+        XWindowAttributes attr;
+        XGetWindowAttributes(x_display, root_window, &attr);
+        XImage image;
+        memset(&image, 0, sizeof(image));
+        image.width = _raw_icon->width;
+        image.height = _raw_icon->height;
+        image.data = (char*)_raw_icon->pixmap;
+        image.byte_order = LSBFirst;
+        image.bitmap_unit = 32;
+        image.bitmap_bit_order = LSBFirst;
+        image.bitmap_pad = 32;
+        image.bytes_per_line = _raw_icon->width * 4;
+        image.depth = 24;
+        image.format = ZPixmap;
+        image.bits_per_pixel = 32;
+        image.red_mask = 0x00ff0000;
+        image.green_mask = 0x0000ff00;
+        image.blue_mask = 0x000000ff;
+
+        if (!XInitImage(&image)) {
+            THROW("init image failed");
+        }
+
+        XGCValues gc_vals;
+        gc_vals.function = GXcopy;
+        gc_vals.foreground = ~0;
+        gc_vals.background = 0;
+        gc_vals.plane_mask = AllPlanes;
+        gc = XCreateGC(x_display, pixmap, GCFunction | GCForeground | GCBackground | GCPlaneMask,
+                       &gc_vals);
+        XPutImage(x_display, pixmap, gc, &image, 0, 0, 0, 0, image.width, image.height);
+        XSync(x_display, False);
+        XFreeGC(x_display, gc);
+        gc = NULL;
+
+        mask = XCreatePixmap(x_display, root_window, _raw_icon->width, _raw_icon->height, 1);
+        if (mask == None) {
+            THROW("create mask failed");
+        }
+
+        memset(&image, 0, sizeof(image));
+        image.width = _raw_icon->width;
+        image.height = _raw_icon->height;
+        image.data = (char*)_raw_icon->mask;
+        image.byte_order = LSBFirst;
+        image.bitmap_unit = 8;
+        image.bitmap_bit_order = MSBFirst;
+        image.bitmap_pad = 8;
+        image.bytes_per_line = _raw_icon->width / 8;
+        image.depth = 1;
+        image.format = XYBitmap;
+        if (!XInitImage(&image)) {
+            THROW("init image failed");
+        }
+
+        gc = XCreateGC(x_display, mask, GCFunction | GCForeground | GCBackground | GCPlaneMask,
+                       &gc_vals);
+        XPutImage(x_display, mask, gc, &image, 0, 0, 0, 0, image.width, image.height);
+        XSync(x_display, False);
+        XFreeGC(x_display, gc);
+    } catch (...) {
+        if (gc) {
+            XFreeGC(x_display, gc);
+        }
+        if (mask) {
+            XFreePixmap(x_display, mask);
+        }
+        if (pixmap) {
+            XFreePixmap(x_display, pixmap);
+        }
+        throw;
+    }
+    _screen_icons[screen] = ScreenIcon(pixmap, mask);
+    out_pixmap = pixmap;
+    out_mask = mask;
+}
+
+Icon* Platform::load_icon(int id)
+{
+    IconsMap::iterator iter = res_icons.find(id);
+    if (iter != res_icons.end()) {
+        return (*iter).second->ref();
+    }
+
+    const IconHeader *icon = res_get_icon(id);
+    if (!icon) {
+        return NULL;
+    }
+    XIcon *xicon = new XIcon(id, icon);
+    return xicon->ref();
+}
+
diff --git a/client/x11/x_icon.h b/client/x11/x_icon.h
new file mode 100644
index 00000000..35797c73
--- /dev/null
+++ b/client/x11/x_icon.h
@@ -0,0 +1,53 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_X_ICON
+#define _H_X_ICON
+
+#include <X11/Xlib.h>
+#include <map>
+
+#include "common.h"
+
+#include "icon.h"
+
+class XIcon: public Icon {
+public:
+    XIcon(int id, const IconHeader *icon);
+
+    void get_pixmaps(int screen, Pixmap& pixmap, Pixmap& mask);
+
+protected:
+    virtual ~XIcon();
+
+private:
+    int _id;
+    const IconHeader* _raw_icon;
+
+    class ScreenIcon {
+    public:
+        ScreenIcon(Pixmap in_pixmap, Pixmap in_mask) : pixmap (in_pixmap), mask (in_mask) {}
+        ScreenIcon() : pixmap (None), mask (None) {}
+
+        Pixmap pixmap;
+        Pixmap mask;
+    };
+    std::map<int, ScreenIcon> _screen_icons;
+};
+
+#endif
+
diff --git a/client/x11/x_platform.h b/client/x11/x_platform.h
new file mode 100644
index 00000000..bc2f691f
--- /dev/null
+++ b/client/x11/x_platform.h
@@ -0,0 +1,36 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_XPLATFORM
+#define _H_XPLATFORM
+
+class XPlatform {
+public:
+    static Display* get_display();
+    static XVisualInfo** get_vinfo();
+    static GLXFBConfig** get_fbconfig();
+
+    typedef void (*win_proc_t)(XEvent& event);
+    static void set_win_proc(Window win, win_proc_t proc);
+    static void cleare_win_proc(Window win);
+
+    static void on_focus_in();
+    static void on_focus_out();
+};
+
+#endif
+
diff --git a/common/.gitignore b/common/.gitignore
new file mode 100644
index 00000000..07491dd4
--- /dev/null
+++ b/common/.gitignore
@@ -0,0 +1,8 @@
+*.la
+*.lo
+*.loT
+*.o
+.deps
+.libs
+Makefile
+Makefile.in
diff --git a/common/Makefile.am b/common/Makefile.am
new file mode 100644
index 00000000..7fcdfe90
--- /dev/null
+++ b/common/Makefile.am
@@ -0,0 +1,49 @@
+NULL =
+
+COMMON_SRCS = 				\
+	cairo_canvas.h			\
+	cairo_canvas.c			\
+	canvas_base.h			\
+	canvas_base.c			\
+	canvas_utils.h			\
+	canvas_utils.c			\
+	draw.h				\
+	gl_canvas.h			\
+	gl_canvas.c			\
+	glc.h				\
+	glc.c				\
+	gl_utils.h			\
+	lookup3.h			\
+	lookup3.c			\
+	lz_common.h			\
+	mutex.h				\
+	ogl_ctx.h			\
+	ogl_ctx.c			\
+	quic.h				\
+	quic.c				\
+	quic_config.h			\
+	qxl_dev.h			\
+	rect.h				\
+	red_error_codes.h		\
+	red.h				\
+	reds_stat.h			\
+	region.h			\
+	region.c			\
+	ring.h				\
+	rop3.h				\
+	rop3.c				\
+	lz.c				\
+	lz_compress_tmpl.c		\
+	lz_config.h			\
+	lz_decompress_tmpl.c		\
+	lz.h				\
+	quic_family_tmpl.c		\
+	quic_rgb_tmpl.c			\
+	quic_tmpl.c			\
+	ipc_ring.h			\
+	vd_agent.h			\
+	quic_tmpl.c			\
+	$(NULL)
+
+EXTRA_DIST = $(COMMON_SRCS)
+
diff --git a/common/cairo_canvas.c b/common/cairo_canvas.c
new file mode 100644
index 00000000..732df919
--- /dev/null
+++ b/common/cairo_canvas.c
@@ -0,0 +1,1664 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "cairo_canvas.h"
+#include "canvas_base.c"
+#include "rop3.h"
+#include "rect.h"
+#include "region.h"
+
+struct CairoCanvas {
+    CanvasBase base;
+    cairo_t *cairo;
+    uint32_t *private_data;
+    int private_data_size;
+};
+
+static void canvas_set_path(CairoCanvas *canvas, void *addr)
+{
+    cairo_t *cairo = canvas->cairo;
+    uint32_t* data_size = (uint32_t*)addr;
+    access_test(&canvas->base, data_size, sizeof(uint32_t));
+    uint32_t more = *data_size;
+
+    PathSeg* seg = (PathSeg*)(data_size + 1);
+
+    do {
+        access_test(&canvas->base, seg, sizeof(PathSeg));
+
+        uint32_t flags = seg->flags;
+        PointFix* point = (PointFix*)seg->data;
+        PointFix* end_point = point + seg->count;
+        access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
+        ASSERT(point < end_point);
+        more -= ((unsigned long)end_point - (unsigned long)seg);
+        seg = (PathSeg*)end_point;
+
+        if (flags & PATH_BEGIN) {
+            cairo_new_sub_path(cairo);
+            cairo_move_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
+            point++;
+        }
+
+        if (flags & PATH_BEZIER) {
+            ASSERT((point - end_point) % 3 == 0);
+            for (; point + 2 < end_point; point += 3) {
+                cairo_curve_to(cairo,
+                               fix_to_double(point[0].x), fix_to_double(point[0].y),
+                               fix_to_double(point[1].x), fix_to_double(point[1].y),
+                               fix_to_double(point[2].x), fix_to_double(point[2].y));
+            }
+        } else {
+            for (; point < end_point; point++) {
+                cairo_line_to(cairo, fix_to_double(point->x), fix_to_double(point->y));
+            }
+        }
+        if (flags & PATH_END) {
+            if (flags & PATH_CLOSE) {
+                cairo_close_path(cairo);
+            }
+            cairo_new_sub_path(cairo);
+        }
+    } while (more);
+}
+
+static void canvas_clip(CairoCanvas *canvas, Clip *clip)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    switch (clip->type) {
+    case CLIP_TYPE_NONE:
+        break;
+    case CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+        access_test(&canvas->base, n, sizeof(uint32_t));
+
+        Rect *now = (Rect *)(n + 1);
+        Rect *end = now + *n;
+        access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+
+        for (; now < end; now++) {
+            cairo_rectangle(cairo, now->left, now->top, now->right - now->left,
+                            now->bottom - now->top);
+        }
+        cairo_clip(cairo);
+        break;
+    }
+    case CLIP_TYPE_PATH:
+        canvas_set_path(canvas, GET_ADDRESS(clip->data));
+        cairo_clip(cairo);
+        break;
+    default:
+        CANVAS_ERROR("invalid clip type");
+    }
+}
+
+static inline cairo_line_cap_t canvas_line_cap_to_cairo(int end_style)
+{
+    switch (end_style) {
+    case LINE_CAP_ROUND:
+        return CAIRO_LINE_CAP_ROUND;
+    case LINE_CAP_SQUARE:
+        return CAIRO_LINE_CAP_SQUARE;
+    case LINE_CAP_BUTT:
+        return CAIRO_LINE_CAP_BUTT;
+    default:
+        CANVAS_ERROR("bad end style %d", end_style);
+    }
+}
+
+static inline cairo_line_join_t canvas_line_join_to_cairo(int join_style)
+{
+    switch (join_style) {
+    case LINE_JOIN_ROUND:
+        return CAIRO_LINE_JOIN_ROUND;
+    case LINE_JOIN_BEVEL:
+        return CAIRO_LINE_JOIN_BEVEL;
+    case LINE_JOIN_MITER:
+        return CAIRO_LINE_JOIN_MITER;
+    default:
+        CANVAS_ERROR("bad join style %d", join_style);
+    }
+}
+
+static void canvas_set_line_attr_no_dash(CairoCanvas *canvas, LineAttr *attr)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    cairo_set_line_width(cairo, fix_to_double(attr->width));
+    cairo_set_line_cap(cairo, canvas_line_cap_to_cairo(attr->end_style));
+    cairo_set_line_join(cairo, canvas_line_join_to_cairo(attr->join_style));
+    cairo_set_miter_limit(cairo, fix_to_double(attr->miter_limit));
+    cairo_set_dash(cairo, NULL, 0, 0);
+}
+
+static void canvas_set_dash(CairoCanvas *canvas, UINT8 nseg, ADDRESS addr, int start_is_gap)
+{
+    FIXED28_4* style = (FIXED28_4*)GET_ADDRESS(addr);
+    double offset = 0;
+    double *local_style;
+    int i;
+
+    access_test(&canvas->base, style, nseg * sizeof(*style));
+
+    if (nseg == 0) {
+        CANVAS_ERROR("bad nseg");
+    }
+    local_style = (double *)malloc(nseg * sizeof(*local_style));
+
+    if (start_is_gap) {
+        offset = fix_to_double(*style);
+        local_style[nseg - 1] = fix_to_double(*style);
+        style++;
+
+        for (i = 0; i < nseg - 1; i++, style++) {
+            local_style[i] = fix_to_double(*style);
+        }
+    } else {
+        for (i = 0; i < nseg; i++, style++) {
+            local_style[i] = fix_to_double(*style);
+        }
+    }
+    cairo_set_dash(canvas->cairo, local_style, nseg, offset);
+    free(local_style);
+}
+
+static inline void canvas_invers_32bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+                                       int width, uint8_t *end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t *src_line = (uint32_t *)src;
+        uint32_t *src_line_end = src_line + width;
+        uint32_t *dest_line = (uint32_t *)dest;
+
+        while (src_line < src_line_end) {
+            *(dest_line++) = ~*(src_line++) & 0x00ffffff;
+        }
+    }
+}
+
+static inline void canvas_invers_24bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+                                       int width, uint8_t *end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint8_t *src_line = src;
+        uint8_t *src_line_end = src_line + width * 3;
+        uint8_t *dest_line = dest;
+
+        for (; src_line < src_line_end; ++dest_line) {
+            *(dest_line++) = ~*(src_line++);
+            *(dest_line++) = ~*(src_line++);
+            *(dest_line++) = ~*(src_line++);
+        }
+    }
+}
+
+static inline void canvas_invers_16bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+                                       int width, uint8_t *end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint16_t *src_line = (uint16_t*)src;
+        uint16_t *src_line_end = src_line + width;
+        uint32_t *dest_line = (uint32_t*)dest;
+
+        for (; src_line < src_line_end; ++dest_line, src_line++) {
+            *dest_line = ~canvas_16bpp_to_32bpp(*src_line) & 0x00ffffff;
+        }
+    }
+}
+
+static inline void canvas_invers_8bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+                                      int width, uint8_t *end, Palette *palette)
+{
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t *dest_line = (uint32_t*)dest;
+        uint8_t *src_line = src;
+        uint8_t *src_line_end = src_line + width;
+
+        while (src_line < src_line_end) {
+            ASSERT(*src_line < palette->num_ents);
+            *(dest_line++) = ~palette->ents[*(src_line++)] & 0x00ffffff;
+        }
+    }
+}
+
+static inline void canvas_invers_4bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
+                                         int src_stride, int width, uint8_t* end,
+                                         Palette *palette)
+{
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t *dest_line = (uint32_t *)dest;
+        uint8_t *now = src;
+        int i;
+
+        for (i = 0; i < (width >> 1); i++) {
+            ASSERT((*now & 0x0f) < palette->num_ents);
+            ASSERT(((*now >> 4) & 0x0f) < palette->num_ents);
+            *(dest_line++) = ~palette->ents[(*now >> 4) & 0x0f] & 0x00ffffff;
+            *(dest_line++) = ~palette->ents[*(now++) & 0x0f] & 0x00ffffff;
+        }
+        if (width & 1) {
+            *(dest_line) = ~palette->ents[(*src >> 4) & 0x0f] & 0x00ffffff;
+        }
+    }
+}
+
+static inline void canvas_invers_1bpp_be(uint8_t* dest, int dest_stride, uint8_t* src,
+                                         int src_stride, int width, uint8_t* end,
+                                         Palette *palette)
+{
+    uint32_t fore_color;
+    uint32_t back_color;
+
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    fore_color = palette->ents[1];
+    back_color = palette->ents[0];
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t* dest_line = (uint32_t*)dest;
+        int i;
+
+        for (i = 0; i < width; i++) {
+            if (test_bit_be(src, i)) {
+                *(dest_line++) = ~fore_color & 0x00ffffff;
+            } else {
+                *(dest_line++) = ~back_color & 0x00ffffff;
+            }
+        }
+    }
+}
+
+static cairo_surface_t *canvas_bitmap_to_invers_surface(CairoCanvas *canvas, Bitmap* bitmap,
+                                                        Palette *palette)
+{
+    uint8_t* src = (uint8_t *)GET_ADDRESS(bitmap->data);
+    int src_stride;
+    uint8_t* end;
+    uint8_t* dest;
+    int dest_stride;
+    cairo_surface_t* cairo_surface;
+
+    src_stride = bitmap->stride;
+    end = src + (bitmap->y * src_stride);
+    access_test(&canvas->base, src, bitmap->y * src_stride);
+
+    cairo_surface = cairo_image_surface_create((bitmap->format == BITMAP_FMT_RGBA) ?
+                                               CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
+                                               bitmap->x, bitmap->y);
+    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(cairo_surface)));
+    }
+    dest = cairo_image_surface_get_data(cairo_surface);
+    dest_stride = cairo_image_surface_get_stride(cairo_surface);
+
+    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+        ASSERT(bitmap->y > 0);
+        dest += dest_stride * (bitmap->y - 1);
+        dest_stride = -dest_stride;
+    }
+    switch (bitmap->format) {
+    case BITMAP_FMT_32BIT:
+    case BITMAP_FMT_RGBA:
+        canvas_invers_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_24BIT:
+        canvas_invers_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_16BIT:
+        canvas_invers_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_8BIT:
+        canvas_invers_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    case BITMAP_FMT_4BIT_BE:
+        canvas_invers_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    case BITMAP_FMT_1BIT_BE:
+        canvas_invers_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    }
+    return cairo_surface;
+}
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+
+#ifndef CAIRO_CANVAS_CACHE
+static Palette *canvas_get_palette(CairoCanvas *canvas, Bitmap *bitmap)
+{
+    Palette *local_palette;
+    Palette *palette;
+    int size;
+
+    if (!bitmap->palette) {
+        return NULL;
+    }
+
+    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    if (canvas->base.color_shift != 5) {
+        return palette;
+    }
+
+    size = sizeof(Palette) + (palette->num_ents << 2);
+    local_palette = malloc(size);
+    memcpy(local_palette, palette, size);
+    canvas_localize_palette(&canvas->base, palette);
+
+    return local_palette;
+}
+
+static void free_palette(Bitmap *bitmap, Palette *palette)
+{
+    if (!palette || palette == GET_ADDRESS(bitmap->palette)) {
+        return;
+    }
+    free(palette);
+}
+
+#endif
+
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+{
+    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    cairo_surface_t *surface;
+    cairo_surface_t *invers = NULL;
+
+    access_test(&canvas->base, descriptor, sizeof(ImageDescriptor));
+
+    int cache_me = descriptor->flags & IMAGE_CACHE_ME;
+
+    switch (descriptor->type) {
+    case IMAGE_TYPE_QUIC: {
+        QUICImage *image = (QUICImage *)descriptor;
+        access_test(&canvas->base, descriptor, sizeof(QUICImage));
+        if (cache_me) {
+            surface = canvas_get_quic(&canvas->base, image, 0);
+        } else {
+            return canvas_get_quic(&canvas->base, image, 1);
+        }
+        break;
+    }
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+    case IMAGE_TYPE_LZ_PLT: {
+        access_test(&canvas->base, descriptor, sizeof(LZ_PLTImage));
+        LZImage *image = (LZImage *)descriptor;
+        if (cache_me) {
+            surface = canvas_get_lz(&canvas->base, image, 0);
+        } else {
+            return canvas_get_lz(&canvas->base, image, 1);
+        }
+        break;
+    }
+    case IMAGE_TYPE_LZ_RGB: {
+        access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+        LZImage *image = (LZImage *)descriptor;
+        if (cache_me) {
+            surface = canvas_get_lz(&canvas->base, image, 0);
+        } else {
+            return canvas_get_lz(&canvas->base, image, 1);
+        }
+        break;
+    }
+#endif
+#ifdef USE_GLZ
+    case IMAGE_TYPE_GLZ_RGB: {
+        access_test(&canvas->base, descriptor, sizeof(LZ_RGBImage));
+        LZImage *image = (LZImage *)descriptor;
+        surface = canvas_get_glz(&canvas->base, image);
+        break;
+    }
+#endif
+    case IMAGE_TYPE_FROM_CACHE:
+        surface = canvas->base.bits_cache_get(canvas->base.bits_cache_opaque, descriptor->id);
+        break;
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)descriptor;
+        access_test(&canvas->base, descriptor, sizeof(BitmapImage));
+        if (cache_me) {
+            surface = canvas_get_bits(&canvas->base, &bitmap->bitmap);
+        } else {
+#ifdef CAIRO_CANVAS_CACHE
+            return canvas_bitmap_to_invers_surface(canvas, &bitmap->bitmap,
+                                                   canvas_get_palett(&canvas->base,
+                                                                     bitmap->bitmap.palette,
+                                                                     bitmap->bitmap.flags));
+#else
+            Palette *palette = canvas_get_palette(canvas, &bitmap->bitmap);
+            surface = canvas_bitmap_to_invers_surface(canvas, &bitmap->bitmap, palette);
+            free_palette(&bitmap->bitmap, palette);
+            return surface;
+#endif
+        }
+        break;
+    }
+    default:
+        CANVAS_ERROR("invalid image type");
+    }
+
+    if (cache_me) {
+        canvas->base.bits_cache_put(canvas->base.bits_cache_opaque, descriptor->id, surface);
+    }
+
+    invers = canvas_handle_inverse_user_data(surface);
+    cairo_surface_destroy(surface);
+    return invers;
+}
+
+#else
+
+static cairo_surface_t *canvas_get_invers(CairoCanvas *canvas, Bitmap *bitmap)
+{
+    Palette *palette;
+
+    if (!bitmap->palette) {
+        return canvas_bitmap_to_invers_surface(canvas, bitmap, NULL);
+    }
+    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    if (canvas->color_shift == 5) {
+        int size = sizeof(Palette) + (palette->num_ents << 2);
+        Palette *local_palette = malloc(size);
+        cairo_surface_t* surface;
+
+        memcpy(local_palette, palette, size);
+        canvas_localize_palette(canvas, palette);
+        surface = canvas_bitmap_to_invers_surface(canvas, bitmap, local_palette);
+        free(local_palette);
+        return surface;
+    } else {
+        return canvas_bitmap_to_invers_surface(canvas, bitmap, palette);
+    }
+}
+
+static cairo_surface_t *canvas_get_invers_image(CairoCanvas *canvas, ADDRESS addr)
+{
+    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+
+    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+
+    switch (descriptor->type) {
+    case IMAGE_TYPE_QUIC: {
+        QUICImage *image = (QUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(QUICImage));
+        return canvas_get_quic(canvas, image, 1);
+    }
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(BitmapImage));
+        return canvas_get_invers(canvas, &bitmap->bitmap);
+    }
+    default:
+        CANVAS_ERROR("invalid image type");
+    }
+}
+
+#endif
+
+static cairo_surface_t* canvas_surface_from_self(CairoCanvas *canvas, Point *pos,
+                                                 int32_t width, int32_t heigth)
+{
+    cairo_surface_t *surface;
+    cairo_surface_t *src_surface;
+    uint8_t *dest;
+    int dest_stride;
+    uint8_t *src;
+    int src_stride;
+    int i;
+
+    surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, heigth);
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+    dest = cairo_image_surface_get_data(surface);
+    dest_stride = cairo_image_surface_get_stride(surface);
+
+    src_surface = cairo_get_target(canvas->cairo);
+    src = cairo_image_surface_get_data(src_surface);
+    src_stride = cairo_image_surface_get_stride(src_surface);
+    src += pos->y * src_stride + (pos->x << 2);
+    for (i = 0; i < heigth; i++, dest += dest_stride, src += src_stride) {
+        memcpy(dest, src, width << 2);
+    }
+    return surface;
+}
+
+static cairo_pattern_t *canvas_get_brush(CairoCanvas *canvas, Brush *brush, uint32_t invers)
+{
+    switch (brush->type) {
+    case BRUSH_TYPE_SOLID: {
+        uint32_t color = (invers) ? ~brush->u.color : brush->u.color;
+        double r, g, b;
+
+        b = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        color >>= canvas->base.color_shift;
+        g = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        color >>= canvas->base.color_shift;
+        r = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        return cairo_pattern_create_rgb(r, g, b);
+    }
+    case BRUSH_TYPE_PATTERN: {
+        cairo_surface_t* surface;
+        cairo_pattern_t *pattern;
+        cairo_matrix_t matrix;
+
+        if (invers) {
+            surface = canvas_get_invers_image(canvas, brush->u.pattern.pat);
+        } else {
+            surface = canvas_get_image(&canvas->base, brush->u.pattern.pat);
+        }
+        pattern = cairo_pattern_create_for_surface(surface);
+        if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+            cairo_surface_destroy(surface);
+            CANVAS_ERROR("create pattern failed, %s",
+                         cairo_status_to_string(cairo_pattern_status(pattern)));
+        }
+        cairo_surface_destroy(surface);
+        cairo_matrix_init_translate(&matrix, -brush->u.pattern.pos.x, -brush->u.pattern.pos.y);
+        cairo_pattern_set_matrix(pattern, &matrix);
+        cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
+        return pattern;
+    }
+    case BRUSH_TYPE_NONE:
+        return NULL;
+    default:
+        CANVAS_ERROR("invalid brush type");
+    }
+}
+
+typedef void (*DrawMethod)(void *);
+
+static inline void __canvas_draw_invers(CairoCanvas *canvas, DrawMethod draw_method, void *data)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_set_source_rgb(cairo, 1, 1, 1);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_XOR);
+    draw_method(data);
+}
+
+static inline int canvas_set_ropd_operator(cairo_t *cairo, uint16_t rop_decriptor)
+{
+    cairo_operator_t cairo_op;
+
+    if (rop_decriptor & ROPD_OP_PUT) {
+        cairo_op = CAIRO_OPERATOR_RASTER_COPY;
+    } else if (rop_decriptor & ROPD_OP_XOR) {
+        cairo_op = CAIRO_OPERATOR_RASTER_XOR;
+    } else if (rop_decriptor & ROPD_OP_OR) {
+        cairo_op = CAIRO_OPERATOR_RASTER_OR;
+    } else if (rop_decriptor & ROPD_OP_AND) {
+        cairo_op = CAIRO_OPERATOR_RASTER_AND;
+    } else {
+        return 0;
+    }
+    cairo_set_operator(cairo, cairo_op);
+    return 1;
+}
+
+static void canvas_draw_with_pattern(CairoCanvas *canvas, cairo_pattern_t *pattern,
+                                     uint16_t rop_decriptor,
+                                     DrawMethod draw_method, void *data)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    if (rop_decriptor & ROPD_OP_BLACKNESS) {
+        cairo_set_source_rgb(cairo, 0, 0, 0);
+        draw_method(data);
+    } else if (rop_decriptor & ROPD_OP_WHITENESS) {
+        cairo_set_source_rgb(cairo, 1, 1, 1);
+        draw_method(data);
+    } else if (rop_decriptor & ROPD_OP_INVERS) {
+        __canvas_draw_invers(canvas, draw_method, data);
+    } else {
+        if (rop_decriptor & ROPD_INVERS_DEST) {
+            __canvas_draw_invers(canvas, draw_method, data);
+        }
+
+        if (canvas_set_ropd_operator(cairo, rop_decriptor)) {
+            ASSERT(pattern);
+            cairo_set_source(cairo, pattern);
+            draw_method(data);
+        }
+
+        if (rop_decriptor & ROPD_INVERS_RES) {
+            __canvas_draw_invers(canvas, draw_method, data);
+        }
+    }
+}
+
+static inline void canvas_draw(CairoCanvas *canvas, Brush *brush, uint16_t rop_decriptor,
+                               DrawMethod draw_method, void *data)
+{
+    cairo_pattern_t *pattern = canvas_get_brush(canvas, brush, rop_decriptor & ROPD_INVERS_BRUSH);
+    canvas_draw_with_pattern(canvas, pattern, rop_decriptor, draw_method, data);
+    if (pattern) {
+        cairo_pattern_destroy(pattern);
+    }
+}
+
+static cairo_pattern_t *canvas_get_mask_pattern(CairoCanvas *canvas, QMask *mask, int x, int y)
+{
+    cairo_surface_t *surface;
+    cairo_pattern_t *pattern;
+    cairo_matrix_t matrix;
+
+    if (!(surface = canvas_get_mask(&canvas->base, mask))) {
+        return NULL;
+    }
+    pattern = cairo_pattern_create_for_surface(surface);
+    if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+        cairo_surface_destroy(surface);
+        CANVAS_ERROR("create pattern failed, %s",
+                     cairo_status_to_string(cairo_pattern_status(pattern)));
+    }
+    cairo_surface_destroy(surface);
+
+    cairo_matrix_init_translate(&matrix, mask->pos.x - x, mask->pos.y - y);
+    cairo_pattern_set_matrix(pattern, &matrix);
+    return pattern;
+}
+
+typedef struct DrawMaskData {
+    cairo_t *cairo;
+    cairo_pattern_t *mask;
+} DrawMaskData;
+
+static void __draw_mask(void *data)
+{
+    cairo_mask(((DrawMaskData *)data)->cairo, ((DrawMaskData *)data)->mask);
+}
+
+void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+{
+    DrawMaskData draw_data;
+    draw_data.cairo = canvas->cairo;
+
+    cairo_save(draw_data.cairo);
+    canvas_clip(canvas, clip);
+    if ((draw_data.mask = canvas_get_mask_pattern(canvas, &fill->mask, bbox->left, bbox->top))) {
+        cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(draw_data.cairo);
+        canvas_draw(canvas, &fill->brush, fill->rop_decriptor, __draw_mask, &draw_data);
+        cairo_pattern_destroy(draw_data.mask);
+    } else {
+        cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        canvas_draw(canvas, &fill->brush, fill->rop_decriptor, (DrawMethod)cairo_fill_preserve,
+                    draw_data.cairo);
+        cairo_new_path(draw_data.cairo);
+    }
+    cairo_restore(draw_data.cairo);
+}
+
+static cairo_pattern_t *canvas_src_image_to_pat(CairoCanvas *canvas, ADDRESS src_bitmap,
+                                                const Rect *src, const Rect *dest, int invers,
+                                                int scale_mode)
+{
+    cairo_pattern_t *pattern;
+    cairo_surface_t *surface;
+    cairo_matrix_t matrix;
+
+    ASSERT(src_bitmap);
+    ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
+    if (invers) {
+        surface = canvas_get_invers_image(canvas, src_bitmap);
+    } else {
+        surface = canvas_get_image(&canvas->base, src_bitmap);
+    }
+
+    pattern = cairo_pattern_create_for_surface(surface);
+    cairo_surface_destroy(surface);
+    if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create pattern failed, %s",
+                     cairo_status_to_string(cairo_pattern_status(pattern)));
+    }
+
+    if (!rect_is_same_size(src, dest)) {
+        double sx, sy;
+
+        sx = (double)(src->right - src->left) / (dest->right - dest->left);
+        sy = (double)(src->bottom - src->top) / (dest->bottom - dest->top);
+
+        cairo_matrix_init_scale(&matrix, sx, sy);
+        cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
+                                 CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
+
+        cairo_matrix_translate(&matrix, src->left / sx - dest->left, src->top / sy - dest->top);
+    } else {
+        cairo_matrix_init_translate(&matrix, src->left - dest->left, src->top - dest->top);
+    }
+
+    cairo_pattern_set_matrix(pattern, &matrix);
+    return pattern;
+}
+
+void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_pattern_t *pattern;
+    cairo_pattern_t *mask;
+
+    cairo_save(cairo);
+    canvas_clip(canvas, clip);
+
+    pattern = canvas_src_image_to_pat(canvas, copy->src_bitmap, &copy->src_area, bbox,
+                                      copy->rop_decriptor & ROPD_INVERS_SRC, copy->scale_mode);
+    cairo_set_source(cairo, pattern);
+    cairo_pattern_destroy(pattern);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    if ((mask = canvas_get_mask_pattern(canvas, &copy->mask, bbox->left, bbox->top))) {
+        cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(cairo);
+        cairo_mask(cairo, mask);
+        cairo_pattern_destroy(mask);
+    } else {
+        cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_fill(cairo);
+    }
+
+    cairo_restore(cairo);
+}
+
+#ifdef WIN32
+void canvas_put_image(CairoCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *_src_data,
+                      uint32_t src_width, uint32_t src_height, int src_stride,
+                      const QRegion *clip)
+#else
+void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *_src_data,
+                      uint32_t src_width, uint32_t src_height, int src_stride,
+                      const QRegion *clip)
+#endif
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_surface_t* surf = NULL;
+    int dest_width;
+    int dest_height;
+    uint8_t *src_data = (uint8_t *)_src_data;
+    uint32_t *data;
+    int nstride;
+
+    cairo_save(cairo);
+
+    if (clip) {
+        const Rect *now = clip->rects;
+        const Rect *end = clip->rects + clip->num_rects;
+        for (; now < end; now++) {
+            cairo_rectangle(cairo, now->left, now->top, now->right - now->left,
+                            now->bottom - now->top);
+        }
+        cairo_clip(cairo);
+    }
+
+
+    dest_width = dest->right - dest->left;
+    dest_height = dest->bottom - dest->top;
+
+    if (dest_width != src_width || dest_height != src_height) {
+        int x, y;
+        int x_mul = (uint32_t)((src_width << 16) / dest_width);
+        int y_mul = (uint32_t)((src_height << 16) / dest_height);
+        int new_y;
+        int set_y;
+        int nsrc_stride;
+
+        if (src_stride < 0) {
+            nsrc_stride = -src_stride;
+            src_data = src_data - (src_height - 1) * nsrc_stride;
+            nsrc_stride = nsrc_stride / 4;
+        } else {
+            nsrc_stride = src_stride / 4;
+        }
+        if ((dest_width * dest_height) > canvas->private_data_size) {
+            if (canvas->private_data) {
+                free(canvas->private_data);
+                canvas->private_data = NULL;
+                canvas->private_data_size = 0;
+            }
+            canvas->private_data = (uint32_t *)malloc(4 * dest_width * dest_height);
+            if (!canvas->private_data) {
+                return;
+            }
+            canvas->private_data_size = dest_width * dest_height;
+        }
+        if (!clip) {
+            surf = cairo_get_target(cairo);
+            data = (uint32_t *)cairo_image_surface_get_data(surf);
+            nstride = cairo_image_surface_get_stride(surf) / 4;
+            data += dest->top * nstride + dest->left + (dest_height - 1) * nstride;
+        } else {
+            data = (uint32_t *)canvas->private_data;
+            nstride = dest_width;
+            data += (dest_height - 1) * nstride;
+        }
+
+        for (y = 0; y < dest_height; ++y) {
+            int y_mul_stride = -y * nstride;
+            new_y = ((y * y_mul) >> 16);
+            set_y = (new_y * nsrc_stride);
+            for (x = 0; x < dest_width; ++x) {
+                data[y_mul_stride + x] = ((uint32_t *)src_data)[set_y + ((x * x_mul) >> 16)];
+            }
+        }
+        if (clip) {
+            surf = cairo_image_surface_create_for_data((uint8_t *)canvas->private_data,
+                                                       CAIRO_FORMAT_RGB24, dest_width,
+                                                       dest_height, 4 * dest_width);
+        }
+    } else {
+        surf = cairo_image_surface_create_for_data((uint8_t *)src_data, CAIRO_FORMAT_RGB24,
+                                                   src_width, src_height, src_stride);
+    }
+
+    if (clip || !(dest_width != src_width || dest_height != src_height)) {
+        cairo_set_source_surface(cairo, surf, dest->left, dest->top);
+        cairo_surface_destroy(surf);
+
+        cairo_rectangle(cairo, dest->left, dest->top, dest_width, dest_height);
+        cairo_fill(cairo);
+    }
+    cairo_restore(cairo);
+}
+
+static cairo_surface_t *canvas_surf_to_color_maks_invers(cairo_surface_t *surface,
+                                                         uint32_t trans_color)
+{
+    int width = cairo_image_surface_get_width(surface);
+    int height = cairo_image_surface_get_height(surface);
+    uint8_t *src_line;
+    uint8_t *end_src_line;
+    int src_stride;
+    uint8_t *dest_line;
+    int dest_stride;
+    cairo_surface_t *mask;
+    int i;
+
+    ASSERT(cairo_image_surface_get_format(surface) == CAIRO_FORMAT_ARGB32 ||
+           cairo_image_surface_get_format(surface) == CAIRO_FORMAT_RGB24);
+
+    mask = cairo_image_surface_create(CAIRO_FORMAT_A1, width, height);
+    if (cairo_surface_status(mask) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(mask)));
+    }
+
+    src_line = cairo_image_surface_get_data(surface);
+    src_stride = cairo_image_surface_get_stride(surface);
+    end_src_line = src_line + src_stride * height;
+
+    dest_line = cairo_image_surface_get_data(mask);
+    dest_stride = cairo_image_surface_get_stride(mask);
+
+    for (; src_line != end_src_line; src_line += src_stride, dest_line += dest_stride) {
+        memset(dest_line, 0xff, dest_stride);
+        for (i = 0; i < width; i++) {
+            if ((((uint32_t*)src_line)[i] & 0x00ffffff) == trans_color) {
+                dest_line[i >> 3] &= ~(1 << (i & 0x07));
+            }
+        }
+    }
+
+    return mask;
+}
+
+void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transparent* transparent)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_pattern_t *pattern;
+    cairo_pattern_t *mask;
+    cairo_surface_t *surface;
+    cairo_surface_t *mask_surf;
+    cairo_matrix_t matrix;
+
+    cairo_save(cairo);
+    cairo_rectangle(cairo,
+                    bbox->left,
+                    bbox->top,
+                    bbox->right - bbox->left,
+                    bbox->bottom - bbox->top);
+    cairo_clip(cairo);
+    canvas_clip(canvas, clip);
+
+    pattern = canvas_src_image_to_pat(canvas, transparent->src_bitmap, &transparent->src_area, bbox,
+                                      0, IMAGE_SCALE_NEAREST);
+    if (cairo_pattern_get_surface(pattern, &surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("surfase from pattern pattern failed");
+    }
+
+    mask_surf = canvas_surf_to_color_maks_invers(surface, transparent->true_color);
+    mask = cairo_pattern_create_for_surface(mask_surf);
+    cairo_surface_destroy(mask_surf);
+    if (cairo_pattern_status(mask) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create pattern failed, %s",
+                     cairo_status_to_string(cairo_pattern_status(pattern)));
+    }
+    cairo_pattern_get_matrix(pattern, &matrix);
+    cairo_pattern_set_matrix(mask, &matrix);
+
+    cairo_set_source(cairo, pattern);
+    cairo_pattern_destroy(pattern);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+    cairo_mask(cairo, mask);
+    cairo_pattern_destroy(mask);
+
+    cairo_restore(cairo);
+}
+
+void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_pattern_t *pattern;
+
+    cairo_save(cairo);
+    cairo_rectangle(cairo,
+                    bbox->left,
+                    bbox->top,
+                    bbox->right - bbox->left,
+                    bbox->bottom - bbox->top);
+    cairo_clip(cairo);
+    canvas_clip(canvas, clip);
+
+    pattern = canvas_src_image_to_pat(canvas, alpha_blend->src_bitmap, &alpha_blend->src_area, bbox,
+                                      0, IMAGE_SCALE_INTERPOLATE);
+    cairo_set_source(cairo, pattern);
+    cairo_pattern_destroy(pattern);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_ATOP);
+    cairo_paint_with_alpha(cairo, (double)alpha_blend->alpha / 0xff);
+
+    cairo_restore(cairo);
+}
+
+void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    cairo_pattern_t *pattern;
+    DrawMaskData draw_data;
+
+    draw_data.cairo = canvas->cairo;
+
+    cairo_save(draw_data.cairo);
+    canvas_clip(canvas, clip);
+
+    pattern = canvas_src_image_to_pat(canvas, opaque->src_bitmap, &opaque->src_area, bbox,
+                                      opaque->rop_decriptor & ROPD_INVERS_SRC, opaque->scale_mode);
+    cairo_set_source(draw_data.cairo, pattern);
+    cairo_pattern_destroy(pattern);
+    cairo_set_operator(draw_data.cairo, CAIRO_OPERATOR_RASTER_COPY);
+    if ((draw_data.mask = canvas_get_mask_pattern(canvas, &opaque->mask, bbox->left, bbox->top))) {
+        cairo_rectangle(draw_data.cairo,
+                        bbox->left,
+                        bbox->top,
+                        bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(draw_data.cairo);
+        cairo_mask(draw_data.cairo, draw_data.mask);
+        canvas_draw(canvas, &opaque->brush, opaque->rop_decriptor, __draw_mask, &draw_data);
+        cairo_pattern_destroy(draw_data.mask);
+    } else {
+        cairo_rectangle(draw_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_fill_preserve(draw_data.cairo);
+        canvas_draw(canvas, &opaque->brush, opaque->rop_decriptor, (DrawMethod)cairo_fill_preserve,
+                    draw_data.cairo);
+        cairo_new_path(draw_data.cairo);
+    }
+
+    cairo_restore(draw_data.cairo);
+}
+
+void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+{
+    cairo_pattern_t *pattern;
+    DrawMaskData mask_data;
+
+    mask_data.cairo = canvas->cairo;
+
+    cairo_save(mask_data.cairo);
+    canvas_clip(canvas, clip);
+
+    pattern = canvas_src_image_to_pat(canvas, blend->src_bitmap, &blend->src_area, bbox,
+                                      blend->rop_decriptor & ROPD_INVERS_SRC, blend->scale_mode);
+
+    if ((mask_data.mask = canvas_get_mask_pattern(canvas, &blend->mask, bbox->left, bbox->top))) {
+        cairo_rectangle(mask_data.cairo,
+                        bbox->left,
+                        bbox->top,
+                        bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(mask_data.cairo);
+        canvas_draw_with_pattern(canvas, pattern, blend->rop_decriptor, __draw_mask, &mask_data);
+        cairo_pattern_destroy(mask_data.mask);
+    } else {
+        cairo_rectangle(mask_data.cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        canvas_draw_with_pattern(canvas, pattern, blend->rop_decriptor,
+                                 (DrawMethod)cairo_fill_preserve,
+                                 mask_data.cairo);
+        cairo_new_path(mask_data.cairo);
+    }
+    cairo_pattern_destroy(pattern);
+    cairo_restore(mask_data.cairo);
+}
+
+static inline void canvas_fill_common(CairoCanvas *canvas, Rect *bbox, Clip *clip,
+                                      QMask *qxl_mask)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_pattern_t *mask;
+
+    canvas_clip(canvas, clip);
+    if ((mask = canvas_get_mask_pattern(canvas, qxl_mask, bbox->left, bbox->top))) {
+        cairo_rectangle(cairo,
+                        bbox->left,
+                        bbox->top,
+                        bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(cairo);
+        cairo_mask(cairo, mask);
+        cairo_pattern_destroy(mask);
+    } else {
+        cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_fill(cairo);
+    }
+}
+
+void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_save(cairo);
+    cairo_set_source_rgb(cairo, 0, 0, 0);
+    canvas_fill_common(canvas, bbox, clip, &blackness->mask);
+    cairo_restore(cairo);
+}
+
+void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_save(cairo);
+    cairo_set_source_rgb(cairo, 1, 1, 1);
+    canvas_fill_common(canvas, bbox, clip, &whiteness->mask);
+    cairo_restore(cairo);
+}
+
+void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_save(cairo);
+    cairo_set_source_rgb(cairo, 1, 1, 1);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_XOR);
+    canvas_fill_common(canvas, bbox, clip, &invers->mask);
+    cairo_restore(cairo);
+}
+
+void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_pattern_t *mask;
+    cairo_surface_t *d;
+    cairo_surface_t *s;
+    Point pos;
+    int width;
+    int heigth;
+    double x_pos;
+    double y_pos;
+    Point src_pos;
+
+    cairo_save(cairo);
+    canvas_clip(canvas, clip);
+    width = bbox->right - bbox->left;
+    heigth = bbox->bottom - bbox->top;
+    x_pos = bbox->left;
+    y_pos = bbox->top;
+    cairo_user_to_device(cairo, &x_pos, &y_pos);
+    pos.x = (INT32)x_pos;
+    pos.y = (INT32)y_pos;
+    d = canvas_surface_from_self(canvas, &pos, width, heigth);
+    s = canvas_get_image(&canvas->base, rop3->src_bitmap);
+
+    if (!rect_is_same_size(bbox, &rop3->src_area)) {
+        cairo_surface_t *scaled_s = canvas_scale_surface(s, &rop3->src_area, width, heigth,
+                                                         rop3->scale_mode);
+        cairo_surface_destroy(s);
+        s = scaled_s;
+        src_pos.x = 0;
+        src_pos.y = 0;
+    } else {
+        src_pos.x = rop3->src_area.left;
+        src_pos.y = rop3->src_area.top;
+    }
+    if (cairo_image_surface_get_width(s) - src_pos.x < width ||
+        cairo_image_surface_get_height(s) - src_pos.y < heigth) {
+        CANVAS_ERROR("bad src bitmap size");
+    }
+    if (rop3->brush.type == BRUSH_TYPE_PATTERN) {
+        cairo_surface_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat);
+        Point pat_pos;
+
+        pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % cairo_image_surface_get_width(p);
+        pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % cairo_image_surface_get_height(p);
+        do_rop3_with_pattern(rop3->rop3, d, s, &src_pos, p, &pat_pos);
+        cairo_surface_destroy(p);
+    } else {
+        uint32_t color = (canvas->base.color_shift) == 8 ? rop3->brush.u.color :
+                                                         canvas_16bpp_to_32bpp(rop3->brush.u.color);
+        do_rop3_with_color(rop3->rop3, d, s, &src_pos, color);
+    }
+    cairo_surface_destroy(s);
+    cairo_set_source_surface(cairo, d, bbox->left, bbox->top);
+    cairo_surface_destroy(d);
+    if ((mask = canvas_get_mask_pattern(canvas, &rop3->mask, bbox->left, bbox->top))) {
+        cairo_rectangle(cairo,
+                        bbox->left,
+                        bbox->top,
+                        bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_clip(cairo);
+        cairo_mask(cairo, mask);
+        cairo_pattern_destroy(mask);
+    } else {
+        cairo_rectangle(cairo, bbox->left, bbox->top, bbox->right - bbox->left,
+                        bbox->bottom - bbox->top);
+        cairo_fill(cairo);
+    }
+    cairo_restore(cairo);
+}
+
+#define FAST_COPY_BITS
+
+#ifdef FAST_COPY_BITS
+
+static inline void __canvas_copy_bits_up(uint8_t *data, const int stride,
+                                         const int src_x, const int src_y,
+                                         const int width, const int height,
+                                         const int dest_x, const int dest_y)
+{
+    uint8_t *src = data + src_y * stride + src_x * sizeof(uint32_t);
+    uint8_t *dest = data + dest_y * stride + dest_x * sizeof(uint32_t);
+    uint8_t *end = dest + height * stride;
+    for (; dest != end; dest += stride, src += stride) {
+        memcpy(dest, src, width * sizeof(uint32_t));
+    }
+}
+
+static inline void __canvas_copy_bits_down(uint8_t *data, const int stride,
+                                           const int src_x, const int src_y,
+                                           const int width, const int height,
+                                           const int dest_x, const int dest_y)
+{
+    uint8_t *src = data + (src_y + height - 1) * stride + src_x * sizeof(uint32_t);
+    uint8_t *end = data + (dest_y - 1) * stride + dest_x * sizeof(uint32_t);
+    uint8_t *dest = end + height * stride;
+
+    for (; dest != end; dest -= stride, src -= stride) {
+        memcpy(dest, src, width * sizeof(uint32_t));
+    }
+}
+
+static inline void __canvas_copy_bits_right(uint8_t *data, const int stride,
+                                            const int src_x, const int src_y,
+                                            const int width, const int height,
+                                            const int dest_x, const int dest_y)
+{
+    uint8_t *src = data + src_y * stride + (src_x + width - 1) * sizeof(uint32_t);
+    uint8_t *dest = data + dest_y * stride + (dest_x + width - 1) * sizeof(uint32_t);
+    uint8_t *end = dest + height * stride;
+    for (; dest != end; dest += stride, src += stride) {
+        uint32_t *src_pix = (uint32_t *)src;
+        uint32_t *end_pix = src_pix - width;
+        uint32_t *dest_pix = (uint32_t *)dest;
+
+        for (; src_pix > end_pix; src_pix--, dest_pix--) {
+            *dest_pix = *src_pix;
+        }
+    }
+}
+
+static inline void __canvas_copy_rect_bits(uint8_t *data, const int stride, Rect *dest_rect,
+                                           Point *src_pos)
+{
+    if (dest_rect->top > src_pos->y) {
+        __canvas_copy_bits_down(data, stride, src_pos->x, src_pos->y,
+                                dest_rect->right - dest_rect->left,
+                                dest_rect->bottom - dest_rect->top,
+                                dest_rect->left, dest_rect->top);
+    } else if (dest_rect->top < src_pos->y || dest_rect->left < src_pos->x) {
+        __canvas_copy_bits_up(data, stride, src_pos->x, src_pos->y,
+                              dest_rect->right - dest_rect->left,
+                              dest_rect->bottom - dest_rect->top,
+                              dest_rect->left, dest_rect->top);
+    } else {
+        __canvas_copy_bits_right(data, stride, src_pos->x, src_pos->y,
+                                 dest_rect->right - dest_rect->left,
+                                 dest_rect->bottom - dest_rect->top,
+                                 dest_rect->left, dest_rect->top);
+    }
+}
+
+static inline void canvas_copy_fix_clip_area(const Rect *dest,
+                                             const Point *src_pos,
+                                             const Rect *now,
+                                             Point *ret_pos,
+                                             Rect *ret_dest)
+{
+    *ret_dest = *now;
+    rect_sect(ret_dest, dest);
+    ret_pos->x = src_pos->x + (ret_dest->left - dest->left);
+    ret_pos->y = src_pos->y + (ret_dest->top - dest->top);
+}
+
+static inline void __canvas_copy_region_bits(uint8_t *data, int stride, Rect *dest_rect,
+                                             Point *src_pos, QRegion *region)
+{
+    Rect curr_area;
+    Point curr_pos;
+    Rect *now;
+    Rect *end;
+
+    if (dest_rect->top > src_pos->y) {
+        end = region->rects - 1;
+        now = end + region->num_rects;
+        if (dest_rect->left < src_pos->x) {
+            for (; now > end; now--) {
+                Rect *line_end = now;
+                Rect *line_pos;
+
+                while (now - 1 > end && now->top == now[-1].top) {
+                    now--;
+                }
+
+                for (line_pos = now; line_pos <= line_end; line_pos++) {
+                    canvas_copy_fix_clip_area(dest_rect, src_pos, line_pos, &curr_pos, &curr_area);
+                    __canvas_copy_bits_down(data, stride, curr_pos.x, curr_pos.y,
+                                            curr_area.right - curr_area.left,
+                                            curr_area.bottom - curr_area.top,
+                                            curr_area.left, curr_area.top);
+                }
+            }
+        } else {
+            for (; now > end; now--) {
+                canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+                __canvas_copy_bits_down(data, stride, curr_pos.x, curr_pos.y,
+                                        curr_area.right - curr_area.left,
+                                        curr_area.bottom - curr_area.top,
+                                        curr_area.left, curr_area.top);
+            }
+        }
+    } else if (dest_rect->top < src_pos->y || dest_rect->left < src_pos->x) {
+        now = region->rects;
+        end = now + region->num_rects;
+        if (dest_rect->left > src_pos->x) {
+            for (; now < end; now++) {
+                Rect *line_end = now;
+                Rect *line_pos;
+
+                while (now + 1 < end && now->top == now[1].top) {
+                    now++;
+                }
+
+                for (line_pos = now; line_pos >= line_end; line_pos--) {
+                    canvas_copy_fix_clip_area(dest_rect, src_pos, line_pos, &curr_pos, &curr_area);
+                    __canvas_copy_bits_up(data, stride, curr_pos.x, curr_pos.y,
+                                          curr_area.right - curr_area.left,
+                                          curr_area.bottom - curr_area.top,
+                                          curr_area.left, curr_area.top);
+                }
+            }
+        } else {
+            for (; now < end; now++) {
+                canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+                __canvas_copy_bits_up(data, stride, curr_pos.x, curr_pos.y,
+                                      curr_area.right - curr_area.left,
+                                      curr_area.bottom - curr_area.top,
+                                      curr_area.left, curr_area.top);
+            }
+        }
+    } else {
+        end = region->rects - 1;
+        now = end + region->num_rects;
+        for (; now > end; now--) {
+            canvas_copy_fix_clip_area(dest_rect, src_pos, now, &curr_pos, &curr_area);
+            __canvas_copy_bits_right(data, stride, curr_pos.x, curr_pos.y,
+                                     curr_area.right - curr_area.left,
+                                     curr_area.bottom - curr_area.top,
+                                     curr_area.left, curr_area.top);
+        }
+    }
+}
+
+#endif
+
+void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_surface_t *surface;
+    int32_t width;
+    int32_t heigth;
+
+    cairo_save(cairo);
+#ifdef FAST_COPY_BITS
+    switch (clip->type) {
+    case CLIP_TYPE_NONE: {
+        surface = cairo_get_target(cairo);
+        __canvas_copy_rect_bits(cairo_image_surface_get_data(surface),
+                                cairo_image_surface_get_stride(surface),
+                                bbox, src_pos);
+        break;
+    }
+    case CLIP_TYPE_RECTS: {
+        surface = cairo_get_target(cairo);
+        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+        access_test(&canvas->base, n, sizeof(uint32_t));
+
+        Rect *now = (Rect *)(n + 1);
+        Rect *end = now + *n;
+        access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+        uint8_t *data = cairo_image_surface_get_data(surface);
+        int stride = cairo_image_surface_get_stride(surface);
+
+        //using QRegion in order to sort and remove intersections
+        QRegion region;
+        region_init(&region);
+        for (; now < end; now++) {
+            region_add(&region, now);
+        }
+        __canvas_copy_region_bits(data, stride, bbox, src_pos, &region);
+        region_destroy(&region);
+        break;
+    }
+    default:
+#endif
+        canvas_clip(canvas, clip);
+
+        width = bbox->right - bbox->left;
+        heigth = bbox->bottom - bbox->top;
+        surface = canvas_surface_from_self(canvas, src_pos, width, heigth);
+        cairo_set_source_surface(cairo, surface, bbox->left, bbox->top);
+        cairo_surface_destroy(surface);
+        cairo_rectangle(cairo, bbox->left, bbox->top, width, heigth);
+        cairo_set_operator(cairo, CAIRO_OPERATOR_RASTER_COPY);
+        cairo_fill(cairo);
+#ifdef FAST_COPY_BITS
+    }
+
+#endif
+    cairo_restore(cairo);
+}
+
+static void canvas_draw_raster_str(CairoCanvas *canvas, String *str, int bpp,
+                                   Brush *brush, uint16_t rop_decriptor)
+{
+    cairo_surface_t *str_mask;
+    DrawMaskData draw_data;
+    cairo_matrix_t matrix;
+    Point pos;
+
+    str_mask = canvas_get_str_mask(&canvas->base, str, bpp, &pos);
+    draw_data.cairo = canvas->cairo;
+    draw_data.mask = cairo_pattern_create_for_surface(str_mask);
+    if (cairo_pattern_status(draw_data.mask) != CAIRO_STATUS_SUCCESS) {
+        cairo_surface_destroy(str_mask);
+        CANVAS_ERROR("create pattern failed, %s",
+                     cairo_status_to_string(cairo_pattern_status(draw_data.mask)));
+    }
+    cairo_matrix_init_translate(&matrix, -pos.x, -pos.y);
+    cairo_pattern_set_matrix(draw_data.mask, &matrix);
+    canvas_draw(canvas, brush, rop_decriptor, __draw_mask, &draw_data);
+    cairo_pattern_destroy(draw_data.mask);
+    cairo_surface_destroy(str_mask);
+}
+
+static void canvas_draw_vector_str(CairoCanvas *canvas, String *str, Brush *brush,
+                                   uint16_t rop_decriptor)
+{
+    VectotGlyph *glyph = (VectotGlyph *)str->data;
+    int i;
+
+    for (i = 0; i < str->length; i++) {
+        VectotGlyph *next_glyph = canvas_next_vector_glyph(glyph);
+        access_test(&canvas->base, glyph, (uint8_t *)next_glyph - (uint8_t *)glyph);
+        canvas_set_path(canvas, glyph->data);
+        glyph = next_glyph;
+    }
+    canvas_draw(canvas, brush, rop_decriptor, (DrawMethod)cairo_fill_preserve, canvas->cairo);
+    cairo_new_path(canvas->cairo);
+}
+
+void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+{
+    cairo_t *cairo = canvas->cairo;
+    String *str;
+
+    cairo_save(cairo);
+    canvas_clip(canvas, clip);
+    if (!rect_is_empty(&text->back_area)) {
+        cairo_rectangle(cairo,
+                        text->back_area.left,
+                        text->back_area.top,
+                        text->back_area.right - text->back_area.left,
+                        text->back_area.bottom - text->back_area.top);
+        canvas_draw(canvas, &text->back_brush, text->back_mode,
+                    (DrawMethod)cairo_fill_preserve, cairo);
+        cairo_new_path(cairo);
+    }
+    str = (String *)GET_ADDRESS(text->str);
+
+    if (str->flags & STRING_RASTER_A1) {
+        canvas_draw_raster_str(canvas, str, 1, &text->fore_brush, text->fore_mode);
+    } else if (str->flags & STRING_RASTER_A4) {
+        canvas_draw_raster_str(canvas, str, 4, &text->fore_brush, text->fore_mode);
+    } else if (str->flags & STRING_RASTER_A8) {
+        WARN("untested path A8 glyphs, doing nothing");
+        if (0) {
+            canvas_draw_raster_str(canvas, str, 8, &text->fore_brush, text->fore_mode);
+        }
+    } else {
+        WARN("untested path vector glyphs, doing nothing");
+        if (0) {
+            canvas_draw_vector_str(canvas, str, &text->fore_brush, text->fore_mode);
+        }
+    }
+    cairo_restore(cairo);
+}
+
+void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    cairo_save(cairo);
+    canvas_clip(canvas, clip);
+
+    canvas_set_line_attr_no_dash(canvas, &stroke->attr);
+    canvas_set_path(canvas, GET_ADDRESS(stroke->path));
+    if (stroke->attr.flags & LINE_ATTR_STYLED) {
+        canvas_draw(canvas, &stroke->brush, stroke->back_mode,
+                    (DrawMethod)cairo_stroke_preserve, cairo);
+        canvas_set_dash(canvas, stroke->attr.style_nseg, stroke->attr.style,
+                        !!(stroke->attr.flags & LINE_ATTR_STARTGAP));
+    }
+    canvas_draw(canvas, &stroke->brush, stroke->fore_mode, (DrawMethod)cairo_stroke_preserve,
+                cairo);
+    cairo_new_path(cairo);
+    cairo_restore(cairo);
+}
+
+void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area)
+{
+    cairo_t *cairo = canvas->cairo;
+    cairo_surface_t* surface;
+    uint8_t *src;
+    int src_stride;
+    uint8_t *dest_end;
+
+    ASSERT(canvas && area);
+
+    surface = cairo_get_target(cairo);
+    src_stride = cairo_image_surface_get_stride(surface);
+    src = cairo_image_surface_get_data(surface) + area->top * src_stride +
+                                                  area->left * sizeof(uint32_t);
+    dest_end = dest + (area->bottom - area->top) * dest_stride;
+    for (; dest != dest_end; dest += dest_stride, src += src_stride) {
+        memcpy(dest, src, dest_stride);
+    }
+}
+
+void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, Rect *clip_rects)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    cairo_save(cairo);
+
+    if (n_clip_rects) {
+        Rect *end = clip_rects + n_clip_rects;
+        for (; clip_rects < end; clip_rects++) {
+            cairo_rectangle(cairo,
+                            clip_rects->left,
+                            clip_rects->top,
+                            clip_rects->right - clip_rects->left,
+                            clip_rects->bottom - clip_rects->top);
+        }
+        cairo_clip(cairo);
+    }
+}
+
+void canvas_group_end(CairoCanvas *canvas)
+{
+    cairo_restore(canvas->cairo);
+}
+
+void canvas_clear(CairoCanvas *canvas)
+{
+    cairo_t *cairo = canvas->cairo;
+
+    ASSERT(cairo);
+    cairo_save(cairo);
+    cairo_reset_clip(cairo);
+    cairo_set_operator(cairo, CAIRO_OPERATOR_CLEAR);
+    cairo_paint(cairo);
+    cairo_restore(cairo);
+}
+
+cairo_t *canvas_get_cairo(CairoCanvas *canvas)
+{
+    return canvas->cairo;
+}
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta, unsigned long base,
+                              unsigned long max)
+{
+    __canvas_set_access_params(&canvas->base, delta, base, max);
+}
+
+#else
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta)
+{
+    __canvas_set_access_params(&canvas->base, delta);
+}
+
+#endif
+
+void canvas_destroy(CairoCanvas *canvas)
+{
+    if (!canvas) {
+        return;
+    }
+    canvas_base_destroy(&canvas->base);
+    if (canvas->private_data) {
+        free(canvas->private_data);
+    }
+    free(canvas);
+}
+
+static int need_init = 1;
+
+#ifdef CAIRO_CANVAS_CACHE
+CairoCanvas *canvas_create(cairo_t *cairo, int bits,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get,
+                           void *palette_cache_opaque, palette_cache_put_fn_t palette_cache_put,
+                           palette_cache_get_fn_t palette_cache_get,
+                           palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+CairoCanvas *canvas_create(cairo_t *cairo, int bits,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get
+#else
+CairoCanvas *canvas_create(cairo_t *cairo, int bits
+#endif
+#ifdef USE_GLZ
+                            , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                           )
+{
+    CairoCanvas *canvas;
+    int init_ok;
+
+    if (need_init || !(canvas = (CairoCanvas *)malloc(sizeof(CairoCanvas)))) {
+        return NULL;
+    }
+    memset(canvas, 0, sizeof(CairoCanvas));
+#ifdef CAIRO_CANVAS_CACHE
+    init_ok = canvas_base_init(&canvas->base, bits,
+                               bits_cache_opaque,
+                               bits_cache_put,
+                               bits_cache_get,
+                               palette_cache_opaque,
+                               palette_cache_put,
+                               palette_cache_get,
+                               palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+    init_ok = canvas_base_init(&canvas->base, bits,
+                               bits_cache_opaque,
+                               bits_cache_put,
+                               bits_cache_get
+#else
+    init_ok = canvas_base_init(&canvas->base, bits
+#endif
+#ifdef USE_GLZ
+                               ,
+                               glz_decoder_opaque,
+                               glz_decode
+#endif
+                               );
+    canvas->cairo = cairo;
+    canvas->private_data = NULL;
+    canvas->private_data_size = 0;
+    cairo_set_antialias(cairo, CAIRO_ANTIALIAS_NONE);
+    return canvas;
+}
+
+void cairo_canvas_init() //unsafe global function
+{
+    if (!need_init) {
+        return;
+    }
+    need_init = 0;
+    rop3_init();
+}
+
diff --git a/common/cairo_canvas.h b/common/cairo_canvas.h
new file mode 100644
index 00000000..3d9a930d
--- /dev/null
+++ b/common/cairo_canvas.h
@@ -0,0 +1,86 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H__CANVAS
+#define _H__CANVAS
+
+#include <stdint.h>
+
+#include "draw.h"
+#include "cairo.h"
+#include "canvas_base.h"
+#include "region.h"
+
+typedef struct CairoCanvas CairoCanvas;
+
+void canvas_draw_fill(CairoCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
+void canvas_draw_copy(CairoCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
+void canvas_draw_opaque(CairoCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
+void canvas_copy_bits(CairoCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
+void canvas_draw_text(CairoCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
+void canvas_draw_stroke(CairoCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
+void canvas_draw_rop3(CairoCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
+void canvas_draw_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
+void canvas_draw_blackness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
+void canvas_draw_whiteness(CairoCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
+void canvas_draw_invers(CairoCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
+void canvas_draw_transparent(CairoCanvas *canvas, Rect *bbox, Clip *clip, Transparent* transparent);
+void canvas_draw_alpha_blend(CairoCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+#ifdef WIN32
+void canvas_put_image(CairoCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+                      uint32_t src_width, uint32_t src_height, int src_stride,
+                      const QRegion *clip);
+#else
+void canvas_put_image(CairoCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+                      uint32_t src_width, uint32_t src_height, int src_stride,
+                      const QRegion *clip);
+#endif
+void canvas_clear(CairoCanvas *canvas);
+void canvas_read_bits(CairoCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area);
+void canvas_group_start(CairoCanvas *canvas, int n_clip_rects, Rect *clip_rects);
+void canvas_group_end(CairoCanvas *canvas);
+void canvas_set_addr_delta(CairoCanvas *canvas, ADDRESS delta);
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta, unsigned long base,
+                              unsigned long max);
+#else
+void canvas_set_access_params(CairoCanvas *canvas, ADDRESS delta);
+#endif
+
+cairo_t *canvas_get_cairo(CairoCanvas *canvas);
+
+#ifdef CAIRO_CANVAS_CACHE
+CairoCanvas *canvas_create(cairo_t *cairo, int bits, void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get,
+                           void *palette_cache_opaque, palette_cache_put_fn_t palette_cache_put,
+                           palette_cache_get_fn_t palette_cache_get,
+                           palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+CairoCanvas *canvas_create(cairo_t *cairo, int bits, void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get
+#else
+CairoCanvas *canvas_create(cairo_t *cairo, int bits
+#endif
+#ifdef USE_GLZ
+                           , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                           );
+void canvas_destroy(CairoCanvas *canvas);
+
+void cairo_canvas_init();
+
+#endif
diff --git a/common/canvas_base.c b/common/canvas_base.c
new file mode 100644
index 00000000..a5519ffc
--- /dev/null
+++ b/common/canvas_base.c
@@ -0,0 +1,1617 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdarg.h>
+#include <cairo.h>
+#include <stdlib.h>
+#include <setjmp.h>
+#include <stdio.h>
+
+#include "draw.h"
+#include "quic.h"
+#include "lz.h"
+#include "canvas_base.h"
+#include "canvas_utils.h"
+#include "rect.h"
+
+#include "mutex.h"
+
+#ifndef CANVAS_ERROR
+#define CANVAS_ERROR(format, ...) {                             \
+    printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__);   \
+    abort();                                                    \
+}
+#endif
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+#define access_test(cancas, ptr, size)                                                         \
+    if ((unsigned long)(ptr) < (cancas)->base ||                                               \
+                                            (unsigned long)(ptr) + (size) > (cancas)->max) {   \
+        CANVAS_ERROR("access violation 0x%lx %lu", (unsigned long)ptr, (unsigned long)(size)); \
+    }
+#else
+#define access_test(cancas, base, size)
+#endif
+
+#ifndef ASSERT
+#define ASSERT(x) if (!(x)) {                               \
+    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
+    abort();                                                \
+}
+#endif
+
+#ifndef WARN
+#define WARN(x) printf("warning: %s\n", x)
+#endif
+
+#ifndef DBG
+#define DBG(level, format, ...) printf("%s: debug: " format "\n", __FUNCTION__, ## __VA_ARGS__);
+#endif
+
+#ifndef ALIGN
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+#endif
+
+#ifndef MIN
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#endif
+
+#ifndef MAX
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+#endif
+
+#ifdef WIN32
+typedef struct  __declspec (align(1)) LZImage {
+#else
+typedef struct __attribute__ ((__packed__)) LZImage {
+#endif
+    ImageDescriptor descriptor;
+    union {
+        LZ_RGBData lz_rgb;
+        LZ_PLTData lz_plt;
+    };
+} LZImage;
+
+static const cairo_user_data_key_t invers_data_type = {0};
+
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+/* should be defined and initialized once in application.cpp */
+extern mutex_t cairo_surface_user_data_mutex;
+#endif
+
+static inline double fix_to_double(FIXED28_4 fixed)
+{
+    return (double)(fixed & 0x0f) / 0x0f + (fixed >> 4);
+}
+
+static inline uint32_t canvas_16bpp_to_32bpp(uint32_t color)
+{
+    uint32_t ret;
+
+    ret = ((color & 0x001f) << 3) | ((color & 0x001c) >> 2);
+    ret |= ((color & 0x03e0) << 6) | ((color & 0x0380) << 1);
+    ret |= ((color & 0x7c00) << 9) | ((color & 0x7000) << 4);
+
+    return ret;
+}
+
+static inline int test_bit(void* addr, int bit)
+{
+    return !!(((uint32_t*)addr)[bit >> 5] & (1 << (bit & 0x1f)));
+}
+
+static inline int test_bit_be(void* addr, int bit)
+{
+    return !!(((uint8_t*)addr)[bit >> 3] & (0x80 >> (bit & 0x07)));
+}
+
+#ifdef WIN32
+static HDC create_compatible_dc()
+{
+    HDC dc = CreateCompatibleDC(NULL);
+    if (!dc) {
+        CANVAS_ERROR("create compatible DC failed");
+    }
+    return dc;
+}
+
+#endif
+
+typedef struct LzData {
+    LzUsrContext usr;
+    LzContext *lz;
+    LzDecodeUsrData decode_data;
+    jmp_buf jmp_env;
+    char message_buf[512];
+} LzData;
+
+typedef struct GlzData {
+    void                  *decoder_opaque;
+    glz_decode_fn_t decode;
+    LzDecodeUsrData decode_data;
+} GlzData;
+
+typedef struct QuicData {
+    QuicUsrContext usr;
+    QuicContext *quic;
+    jmp_buf jmp_env;
+#ifndef CAIRO_CANVAS_NO_CHUNKS
+    ADDRESS next;
+    ADDRESS address_delta;
+#endif
+    char message_buf[512];
+} QuicData;
+
+typedef struct CanvasBase {
+    uint32_t color_shift;
+    uint32_t color_mask;
+    QuicData quic_data;
+    ADDRESS address_delta;
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+    unsigned long base;
+    unsigned long max;
+#endif
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+    void *bits_cache_opaque;
+    bits_cache_put_fn_t bits_cache_put;
+    bits_cache_get_fn_t bits_cache_get;
+#endif
+#ifdef CAIRO_CANVAS_CACHE
+    void *palette_cache_opaque;
+    palette_cache_put_fn_t palette_cache_put;
+    palette_cache_get_fn_t palette_cache_get;
+    palette_cache_release_fn_t palette_cache_release;
+#endif
+#ifdef WIN32
+    HDC dc;
+#endif
+
+    LzData lz_data;
+    GlzData glz_data;
+} CanvasBase;
+
+
+#ifndef CAIRO_CANVAS_NO_CHUNKS
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#endif
+
+typedef struct ATTR_PACKED DataChunk {
+    UINT32 size;
+    ADDRESS prev;
+    ADDRESS next;
+    UINT8 data[0];
+} DataChunk;
+
+#undef ATTR_PACKED
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#endif
+
+
+static inline void canvas_localize_palette(CanvasBase *canvas, Palette *palette)
+{
+    if (canvas->color_shift == 5) {
+        UINT32 *now = palette->ents;
+        UINT32 *end = now + palette->num_ents;
+        for (; now < end; now++) {
+            *now = canvas_16bpp_to_32bpp(*now);
+        }
+    }
+}
+
+//#define DEBUG_DUMP_COMPRESS
+#ifdef DEBUG_DUMP_COMPRESS
+static void dump_surface(cairo_surface_t *surface, int cache);
+#endif
+static cairo_surface_t *canvas_get_quic(CanvasBase *canvas, QUICImage *image, int invers)
+{
+    cairo_surface_t *surface = NULL;
+    QuicData *quic_data = &canvas->quic_data;
+    QuicImageType type;
+    uint8_t *dest;
+    int stride;
+    int width;
+    int height;
+    int alpha;
+#ifndef CAIRO_CANVAS_NO_CHUNKS
+    DataChunk **tmp;
+    DataChunk *chunk;
+#endif
+
+    if (setjmp(quic_data->jmp_env)) {
+        cairo_surface_destroy(surface);
+        CANVAS_ERROR("quic error, %s", quic_data->message_buf);
+    }
+
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+    if (quic_decode_begin(quic_data->quic, (uint32_t *)image->quic.data,
+                          image->quic.data_size >> 2, &type, &width, &height) == QUIC_ERROR) {
+        CANVAS_ERROR("quic decode begin failed");
+    }
+#else
+    tmp = (DataChunk **)image->quic.data;
+    chunk = *tmp;
+    quic_data->next = chunk->next;
+    quic_data->address_delta = canvas->address_delta;
+    if (quic_decode_begin(quic_data->quic, (uint32_t *)chunk->data, chunk->size >> 2,
+                          &type, &width, &height) == QUIC_ERROR) {
+        CANVAS_ERROR("quic decode begin failed");
+    }
+#endif
+
+    switch (type) {
+    case QUIC_IMAGE_TYPE_RGBA:
+        alpha = 1;
+        break;
+    case QUIC_IMAGE_TYPE_RGB32:
+    case QUIC_IMAGE_TYPE_RGB24:
+    case QUIC_IMAGE_TYPE_RGB16:
+        alpha = 0;
+        break;
+    case QUIC_IMAGE_TYPE_INVALID:
+    case QUIC_IMAGE_TYPE_GRAY:
+    default:
+        CANVAS_ERROR("unexpected image type");
+    }
+
+    ASSERT((uint32_t)width == image->descriptor.width);
+    ASSERT((uint32_t)height == image->descriptor.height);
+
+    surface = surface_create(
+#ifdef WIN32
+                             canvas->dc,
+#endif
+                             alpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24,
+                             width, height, FALSE);
+
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+
+    dest = cairo_image_surface_get_data(surface);
+    stride = cairo_image_surface_get_stride(surface);
+    if (quic_decode(quic_data->quic, alpha ? QUIC_IMAGE_TYPE_RGBA : QUIC_IMAGE_TYPE_RGB32,
+                    dest, stride) == QUIC_ERROR) {
+        CANVAS_ERROR("quic decode failed");
+    }
+
+    if (invers) {
+        uint8_t *end = dest + height * stride;
+        for (; dest != end; dest += stride) {
+            uint32_t *pix;
+            uint32_t *end_pix;
+
+            pix = (uint32_t *)dest;
+            end_pix = pix + width;
+            for (; pix < end_pix; pix++) {
+                *pix ^= 0x00ffffff;
+            }
+        }
+    }
+
+#ifdef DEBUG_DUMP_COMPRESS
+    dump_surface(surface, 0);
+#endif
+    return surface;
+}
+
+static inline void canvas_copy_32bpp(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
+                                     int width, uint8_t* end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        memcpy(dest, src, width << 2);
+    }
+}
+
+static inline void canvas_copy_24bpp(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
+                                     int width, uint8_t* end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint8_t* src_line = src;
+        uint8_t* src_line_end = src_line + width * 3;
+        uint8_t* dest_line = dest;
+
+        for (; src_line < src_line_end; ++dest_line) {
+            *(dest_line++) = *(src_line++);
+            *(dest_line++) = *(src_line++);
+            *(dest_line++) = *(src_line++);
+        }
+    }
+}
+
+static inline void canvas_copy_16bpp(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
+                                     int width, uint8_t* end)
+{
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint16_t* src_line = (uint16_t*)src;
+        uint16_t* src_line_end = src_line + width;
+        uint32_t* dest_line = (uint32_t*)dest;
+
+        for (; src_line < src_line_end; ++dest_line, src_line++) {
+            *dest_line = canvas_16bpp_to_32bpp(*src_line);
+        }
+    }
+}
+
+static inline void canvas_copy_8bpp(uint8_t *dest, int dest_stride, uint8_t *src, int src_stride,
+                                    int width, uint8_t *end, Palette *palette)
+{
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t *dest_line = (uint32_t*)dest;
+        uint8_t *src_line = src;
+        uint8_t *src_line_end = src_line + width;
+
+        while (src_line < src_line_end) {
+            ASSERT(*src_line < palette->num_ents);
+            *(dest_line++) = palette->ents[*(src_line++)];
+        }
+    }
+}
+
+static inline void canvas_copy_4bpp_be(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
+                                       int width, uint8_t* end, Palette *palette)
+{
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t *dest_line = (uint32_t *)dest;
+        uint8_t *now = src;
+        int i;
+
+        for (i = 0; i < (width >> 1); i++) {
+            ASSERT((*now & 0x0f) < palette->num_ents);
+            ASSERT(((*now >> 4) & 0x0f) < palette->num_ents);
+            *(dest_line++) = palette->ents[(*now >> 4) & 0x0f];
+            *(dest_line++) = palette->ents[*(now++) & 0x0f];
+        }
+        if (width & 1) {
+            *(dest_line) = palette->ents[(*src >> 4) & 0x0f];
+        }
+    }
+}
+
+static inline void canvas_copy_1bpp_be(uint8_t* dest, int dest_stride, uint8_t* src, int src_stride,
+                                       int width, uint8_t* end, Palette *palette)
+{
+    uint32_t fore_color;
+    uint32_t back_color;
+
+    if (!palette) {
+        CANVAS_ERROR("no palette");
+    }
+
+    fore_color = palette->ents[1];
+    back_color = palette->ents[0];
+
+    for (; src != end; src += src_stride, dest += dest_stride) {
+        uint32_t* dest_line = (uint32_t*)dest;
+        int i;
+
+        for (i = 0; i < width; i++) {
+            if (test_bit_be(src, i)) {
+                *(dest_line++) = fore_color;
+            } else {
+                *(dest_line++) = back_color;
+            }
+        }
+    }
+}
+
+static cairo_surface_t *canvas_bitmap_to_surface(CanvasBase *canvas, Bitmap* bitmap,
+                                                 Palette *palette)
+{
+    uint8_t* src = (uint8_t *)GET_ADDRESS(bitmap->data);
+    int src_stride;
+    uint8_t* end;
+    uint8_t* dest;
+    int dest_stride;
+    cairo_surface_t* cairo_surface;
+
+    src_stride = bitmap->stride;
+    end = src + (bitmap->y * src_stride);
+    access_test(canvas, src, bitmap->y * src_stride);
+
+    cairo_surface = surface_create(
+#ifdef WIN32
+                                   canvas->dc,
+#endif
+                                   (bitmap->format == BITMAP_FMT_RGBA) ? CAIRO_FORMAT_ARGB32 :
+                                                                         CAIRO_FORMAT_RGB24,
+                                   bitmap->x, bitmap->y, FALSE);
+    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(cairo_surface)));
+    }
+    dest = cairo_image_surface_get_data(cairo_surface);
+    dest_stride = cairo_image_surface_get_stride(cairo_surface);
+    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+        ASSERT(bitmap->y > 0);
+        dest += dest_stride * ((int)bitmap->y - 1);
+        dest_stride = -dest_stride;
+    }
+
+    switch (bitmap->format) {
+    case BITMAP_FMT_32BIT:
+    case BITMAP_FMT_RGBA:
+        canvas_copy_32bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_24BIT:
+        canvas_copy_24bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_16BIT:
+        canvas_copy_16bpp(dest, dest_stride, src, src_stride, bitmap->x, end);
+        break;
+    case BITMAP_FMT_8BIT:
+        canvas_copy_8bpp(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    case BITMAP_FMT_4BIT_BE:
+        canvas_copy_4bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    case BITMAP_FMT_1BIT_BE:
+        canvas_copy_1bpp_be(dest, dest_stride, src, src_stride, bitmap->x, end, palette);
+        break;
+    }
+    return cairo_surface;
+}
+
+#ifdef CAIRO_CANVAS_CACHE
+
+static inline Palette *canvas_get_palett(CanvasBase *canvas, ADDRESS base_palette, uint8_t flags)
+{
+    Palette *palette;
+    if (!base_palette) {
+        return NULL;
+    }
+
+    if (flags & BITMAP_PAL_FROM_CACHE) {
+        palette = canvas->palette_cache_get(canvas->palette_cache_opaque, base_palette);
+    } else if (flags & BITMAP_PAL_CACHE_ME) {
+        palette = (Palette *)GET_ADDRESS(base_palette);
+        access_test(canvas, palette, sizeof(Palette));
+        access_test(canvas, palette, sizeof(Palette) + palette->num_ents * sizeof(uint32_t));
+        canvas_localize_palette(canvas, palette);
+        canvas->palette_cache_put(canvas->palette_cache_opaque, palette);
+    } else {
+        palette = (Palette *)GET_ADDRESS(base_palette);
+        canvas_localize_palette(canvas, palette);
+    }
+    return palette;
+}
+
+static cairo_surface_t *canvas_get_lz(CanvasBase *canvas, LZImage *image, int invers)
+{
+    LzData *lz_data = &canvas->lz_data;
+    uint8_t *comp_buf = NULL;
+    int comp_size;
+    uint8_t    *decomp_buf = NULL;
+    uint8_t    *src;
+    LzImageType type;
+    Palette *palette;
+    int alpha;
+    int n_comp_pixels;
+    int width;
+    int height;
+    int top_down;
+    int stride;
+
+    if (setjmp(lz_data->jmp_env)) {
+        if (decomp_buf) {
+            free(decomp_buf);
+        }
+        CANVAS_ERROR("lz error, %s", lz_data->message_buf);
+    }
+
+    if (image->descriptor.type == IMAGE_TYPE_LZ_RGB) {
+        comp_buf = image->lz_rgb.data;
+        comp_size = image->lz_rgb.data_size;
+        palette = NULL;
+    } else if (image->descriptor.type == IMAGE_TYPE_LZ_PLT) {
+        comp_buf = image->lz_plt.data;
+        comp_size = image->lz_plt.data_size;
+        palette = canvas_get_palett(canvas, image->lz_plt.palette, image->lz_plt.flags);
+    } else {
+        CANVAS_ERROR("unexpected image type");
+    }
+
+    lz_decode_begin(lz_data->lz, comp_buf, comp_size, &type,
+                    &width, &height, &n_comp_pixels, &top_down, palette);
+
+    switch (type) {
+    case LZ_IMAGE_TYPE_RGBA:
+        alpha = 1;
+        break;
+    case LZ_IMAGE_TYPE_RGB32:
+    case LZ_IMAGE_TYPE_RGB24:
+    case LZ_IMAGE_TYPE_RGB16:
+    case LZ_IMAGE_TYPE_PLT1_LE:
+    case LZ_IMAGE_TYPE_PLT1_BE:
+    case LZ_IMAGE_TYPE_PLT4_LE:
+    case LZ_IMAGE_TYPE_PLT4_BE:
+    case LZ_IMAGE_TYPE_PLT8:
+        alpha = 0;
+        break;
+    default:
+        CANVAS_ERROR("unexpected LZ image type");
+    }
+
+    ASSERT(width == image->descriptor.width);
+    ASSERT(height == image->descriptor.height);
+
+    ASSERT((image->descriptor.type == IMAGE_TYPE_LZ_PLT) || (n_comp_pixels == width * height));
+#ifdef WIN32
+    lz_data->decode_data.dc = canvas->dc;
+#endif
+
+
+    alloc_lz_image_surface(&lz_data->decode_data, alpha ? LZ_IMAGE_TYPE_RGBA : LZ_IMAGE_TYPE_RGB32,
+                           width, height, n_comp_pixels, top_down);
+
+    src = cairo_image_surface_get_data(lz_data->decode_data.out_surface);
+
+    stride = (n_comp_pixels / height) * 4;
+    if (!top_down) {
+        stride = -stride;
+        decomp_buf = src + stride * (height - 1);
+    } else {
+        decomp_buf = src;
+    }
+
+    lz_decode(lz_data->lz, alpha ? LZ_IMAGE_TYPE_RGBA : LZ_IMAGE_TYPE_RGB32, decomp_buf);
+
+    if (invers) {
+        uint8_t *line = src;
+        uint8_t *end = src + height * stride;
+        for (; line != end; line += stride) {
+            uint32_t *pix;
+            uint32_t *end_pix;
+
+            pix = (uint32_t *)line;
+            end_pix = pix + width;
+            for (; pix < end_pix; pix++) {
+                *pix ^= 0x00ffffff;
+            }
+        }
+    }
+
+    return lz_data->decode_data.out_surface;
+}
+
+// don't handle plts since bitmaps with plt can be decoded globaly to RGB32 (because
+// same byte sequence can be transformed to different RGB pixels by different plts)
+static cairo_surface_t *canvas_get_glz(CanvasBase *canvas, LZImage *image)
+{
+    ASSERT(image->descriptor.type == IMAGE_TYPE_GLZ_RGB);
+#ifdef WIN32
+    canvas->glz_data.decode_data.dc = canvas->dc;
+#endif
+    canvas->glz_data.decode(canvas->glz_data.decoder_opaque, image->lz_rgb.data, NULL,
+                            &canvas->glz_data.decode_data);
+    /* global_decode calls alloc_lz_image, which sets canvas->glz_data.surface */
+    return (canvas->glz_data.decode_data.out_surface);
+}
+
+//#define DEBUG_DUMP_BITMAP
+
+#ifdef DEBUG_DUMP_BITMAP
+static void dump_bitmap(Bitmap *bitmap, Palette *palette)
+{
+    uint8_t* data = (uint8_t *)GET_ADDRESS(bitmap->data);
+    static uint32_t file_id = 0;
+    uint32_t i, j;
+    char file_str[200];
+    uint32_t id = ++file_id;
+
+#ifdef WIN32
+    sprintf(file_str, "c:\\tmp\\spice_dump\\%u.%ubpp", id, bitmap->format);
+#else
+    sprintf(file_str, "/tmp/spice_dump/%u.%ubpp", id, bitmap->format);
+#endif
+    FILE *f = fopen(file_str, "wb");
+    if (!f) {
+        return;
+    }
+
+    fprintf(f, "%d\n", bitmap->format);                          // 1_LE,1_BE,....
+    fprintf(f, "%d %d\n", bitmap->x, bitmap->y);     // width and height
+    fprintf(f, "%d\n", palette->num_ents);               // #plt entries
+    for (i = 0; i < palette->num_ents; i++) {
+        fwrite(&(palette->ents[i]), 4, 1, f);
+    }
+    fprintf(f, "\n");
+
+    for (i = 0; i < bitmap->y; i++, data += bitmap->stride) {
+        uint8_t *now = data;
+        for (j = 0; j < bitmap->x; j++) {
+            fwrite(now, 1, 1, f);
+            now++;
+        }
+    }
+}
+
+#endif
+
+static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
+{
+    cairo_surface_t* surface;
+    Palette *palette;
+
+    palette = canvas_get_palett(canvas, bitmap->palette, bitmap->flags);
+#ifdef DEBUG_DUMP_BITMAP
+    if (palette) {
+        dump_bitmap(bitmap, palette);
+    }
+#endif
+
+    surface = canvas_bitmap_to_surface(canvas, bitmap, palette);
+
+    if (palette && (bitmap->flags & BITMAP_PAL_FROM_CACHE)) {
+        canvas->palette_cache_release(palette);
+    }
+
+    return surface;
+}
+
+#else
+
+
+static cairo_surface_t *canvas_get_bits(CanvasBase *canvas, Bitmap *bitmap)
+{
+    Palette *palette;
+
+    if (!bitmap->palette) {
+        return canvas_bitmap_to_surface(canvas, bitmap, NULL);
+    }
+    palette = (Palette *)GET_ADDRESS(bitmap->palette);
+    if (canvas->color_shift == 5) {
+        int size = sizeof(Palette) + (palette->num_ents << 2);
+        Palette *local_palette = malloc(size);
+        cairo_surface_t* surface;
+
+        memcpy(local_palette, palette, size);
+        canvas_localize_palette(canvas, local_palette);
+        surface = canvas_bitmap_to_surface(canvas, bitmap, local_palette);
+        free(local_palette);
+        return surface;
+    } else {
+        return canvas_bitmap_to_surface(canvas, bitmap, palette);
+    }
+}
+
+#endif
+
+
+
+// caution: defining DEBUG_DUMP_SURFACE will dump both cached & non-cached
+//          images to disk. it will reduce performance dramatically & eat
+//          disk space rapidly. use it only for debugging.
+//#define DEBUG_DUMP_SURFACE
+
+#if defined(DEBUG_DUMP_SURFACE) || defined(DEBUG_DUMP_COMPRESS)
+
+static void dump_surface(cairo_surface_t *surface, int cache)
+{
+    static uint32_t file_id = 0;
+    int i, j;
+    char file_str[200];
+    cairo_format_t format = cairo_image_surface_get_format(surface);
+
+    if (format != CAIRO_FORMAT_RGB24 && format != CAIRO_FORMAT_ARGB32) {
+        return;
+    }
+
+    uint8_t *data = cairo_image_surface_get_data(surface);
+    int width = cairo_image_surface_get_width(surface);
+    int height = cairo_image_surface_get_height(surface);
+    int stride = cairo_image_surface_get_stride(surface);
+
+    uint32_t id = ++file_id;
+#ifdef WIN32
+    sprintf(file_str, "c:\\tmp\\spice_dump\\%d\\%u.ppm", cache, id);
+#else
+    sprintf(file_str, "/tmp/spice_dump/%u.ppm", id);
+#endif
+    FILE *f = fopen(file_str, "wb");
+    if (!f) {
+        return;
+    }
+    fprintf(f, "P6\n");
+    fprintf(f, "%d %d\n", width, height);
+    fprintf(f, "#spicec dump\n");
+    fprintf(f, "255\n");
+    for (i = 0; i < height; i++, data += stride) {
+        uint8_t *now = data;
+        for (j = 0; j < width; j++) {
+            fwrite(&now[2], 1, 1, f);
+            fwrite(&now[1], 1, 1, f);
+            fwrite(&now[0], 1, 1, f);
+            now += 4;
+        }
+    }
+    fclose(f);
+}
+
+#endif
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+
+static void __release_surface(void *inv_surf)
+{
+    cairo_surface_destroy((cairo_surface_t *)inv_surf);
+}
+
+//#define DEBUG_LZ
+
+static cairo_surface_t *canvas_get_image(CanvasBase *canvas, ADDRESS addr)
+{
+    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+    cairo_surface_t *surface;
+    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+#ifdef DEBUG_LZ
+    LOG_DEBUG("canvas_get_image image type: " << (int)descriptor->type);
+#endif
+
+    switch (descriptor->type) {
+    case IMAGE_TYPE_QUIC: {
+        QUICImage *image = (QUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(QUICImage));
+        surface = canvas_get_quic(canvas, image, 0);
+        break;
+    }
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+    case IMAGE_TYPE_LZ_PLT: {
+        access_test(canvas, descriptor, sizeof(LZ_PLTImage));
+        LZImage *image = (LZImage *)descriptor;
+        surface = canvas_get_lz(canvas, image, 0);
+        break;
+    }
+    case IMAGE_TYPE_LZ_RGB: {
+        access_test(canvas, descriptor, sizeof(LZ_RGBImage));
+        LZImage *image = (LZImage *)descriptor;
+        surface = canvas_get_lz(canvas, image, 0);
+        break;
+    }
+#endif
+#ifdef USE_GLZ
+    case IMAGE_TYPE_GLZ_RGB: {
+        access_test(canvas, descriptor, sizeof(LZ_RGBImage));
+        LZImage *image = (LZImage *)descriptor;
+        surface = canvas_get_glz(canvas, image);
+        break;
+    }
+#endif
+    case IMAGE_TYPE_FROM_CACHE:
+        return canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(BitmapImage));
+        surface = canvas_get_bits(canvas, &bitmap->bitmap);
+        break;
+    }
+    default:
+        CANVAS_ERROR("invalid image type");
+    }
+
+    if (descriptor->flags & IMAGE_CACHE_ME) {
+        canvas->bits_cache_put(canvas->bits_cache_opaque, descriptor->id, surface);
+#ifdef DEBUG_DUMP_SURFACE
+        dump_surface(surface, 1);
+#endif
+    } else if (descriptor->type != IMAGE_TYPE_FROM_CACHE) {
+#ifdef DEBUG_DUMP_SURFACE
+        dump_surface(surface, 0);
+#endif
+    }
+    return surface;
+}
+
+#else
+
+static cairo_surface_t *canvas_get_image(CairoCanvas *canvas, ADDRESS addr)
+{
+    ImageDescriptor *descriptor = (ImageDescriptor *)GET_ADDRESS(addr);
+
+    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+
+    switch (descriptor->type) {
+    case IMAGE_TYPE_QUIC: {
+        QUICImage *image = (QUICImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(QUICImage));
+        return canvas_get_quic(canvas, image, 0);
+    }
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(BitmapImage));
+        return canvas_get_bits(canvas, &bitmap->bitmap);
+    }
+    default:
+        CANVAS_ERROR("invalid image type");
+    }
+}
+
+#endif
+
+static inline uint8_t revers_bits(uint8_t byte)
+{
+    uint8_t ret = 0;
+    int i;
+
+    for (i = 0; i < 4; i++) {
+        int shift = 7 - i * 2;
+        ret |= (byte & (1 << i)) << shift;
+        ret |= (byte & (0x80 >> i)) >> shift;
+    }
+    return ret;
+}
+
+static cairo_surface_t *canvas_get_bitmap_mask(CanvasBase *canvas, Bitmap* bitmap, int invers)
+{
+    cairo_surface_t *surface;
+    uint8_t *src_line;
+    uint8_t *end_line;
+    uint8_t *dest_line;
+    int src_stride;
+    int line_size;
+    int dest_stride;
+
+    surface = surface_create(
+#ifdef WIN32
+            canvas->dc,
+#endif
+            CAIRO_FORMAT_A1, bitmap->x, bitmap->y, TRUE);
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+
+    src_line = (uint8_t *)GET_ADDRESS(bitmap->data);
+    src_stride = bitmap->stride;
+    end_line = src_line + (bitmap->y * src_stride);
+    access_test(canvas, src_line, end_line - src_line);
+    line_size = ALIGN(bitmap->x, 8) >> 3;
+
+    dest_stride = cairo_image_surface_get_stride(surface);
+    dest_line = cairo_image_surface_get_data(surface);
+#if defined(GL_CANVAS)
+    if ((bitmap->flags & BITMAP_TOP_DOWN)) {
+#else
+    if (!(bitmap->flags & BITMAP_TOP_DOWN)) {
+#endif
+        ASSERT(bitmap->y > 0);
+        dest_line += dest_stride * ((int)bitmap->y - 1);
+        dest_stride = -dest_stride;
+    }
+
+    if (invers) {
+        switch (bitmap->format) {
+#if defined(GL_CANVAS) || defined(GDI_CANVAS)
+        case BITMAP_FMT_1BIT_BE:
+#else
+        case BITMAP_FMT_1BIT_LE:
+#endif
+            for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
+                uint8_t *dest = dest_line;
+                uint8_t *now = src_line;
+                uint8_t *end = now + line_size;
+                while (now < end) {
+                    *(dest++) = ~*(now++);
+                }
+            }
+            break;
+#if defined(GL_CANVAS) || defined(GDI_CANVAS)
+        case BITMAP_FMT_1BIT_LE:
+#else
+        case BITMAP_FMT_1BIT_BE:
+#endif
+            for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
+                uint8_t *dest = dest_line;
+                uint8_t *now = src_line;
+                uint8_t *end = now + line_size;
+
+                while (now < end) {
+                    *(dest++) = ~revers_bits(*(now++));
+                }
+            }
+            break;
+        default:
+            cairo_surface_destroy(surface);
+            CANVAS_ERROR("invalid bitmap format");
+        }
+    } else {
+        switch (bitmap->format) {
+#if defined(GL_CANVAS) || defined(GDI_CANVAS)
+        case BITMAP_FMT_1BIT_BE:
+#else
+        case BITMAP_FMT_1BIT_LE:
+#endif
+            for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
+                memcpy(dest_line, src_line, line_size);
+            }
+            break;
+#if defined(GL_CANVAS) || defined(GDI_CANVAS)
+        case BITMAP_FMT_1BIT_LE:
+#else
+        case BITMAP_FMT_1BIT_BE:
+#endif
+            for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
+                uint8_t *dest = dest_line;
+                uint8_t *now = src_line;
+                uint8_t *end = now + line_size;
+
+                while (now < end) {
+                    *(dest++) = revers_bits(*(now++));
+                }
+            }
+            break;
+        default:
+            cairo_surface_destroy(surface);
+            CANVAS_ERROR("invalid bitmap format");
+        }
+    }
+    return surface;
+}
+
+static inline cairo_surface_t *canvas_A1_invers(cairo_surface_t *src_surf)
+{
+    int width = cairo_image_surface_get_width(src_surf);
+    int height = cairo_image_surface_get_height(src_surf);
+
+    cairo_surface_t * invers = cairo_image_surface_create(CAIRO_FORMAT_A1, width, height);
+    if (cairo_surface_status(invers) == CAIRO_STATUS_SUCCESS) {
+        uint8_t *src_line = cairo_image_surface_get_data(src_surf);
+        int src_stride = cairo_image_surface_get_stride(src_surf);
+        uint8_t *end_line = src_line + (height * src_stride);
+        int line_size = ALIGN(width, 8) >> 3;
+        uint8_t *dest_line = cairo_image_surface_get_data(invers);
+        int dest_stride = cairo_image_surface_get_stride(invers);
+
+        for (; src_line != end_line; src_line += src_stride, dest_line += dest_stride) {
+            uint8_t *dest = dest_line;
+            uint8_t *now = src_line;
+            uint8_t *end = now + line_size;
+            while (now < end) {
+                *(dest++) = ~*(now++);
+            }
+        }
+    }
+    return invers;
+}
+
+static cairo_surface_t *canvas_surf_to_invers(cairo_surface_t *surf)
+{
+    int width = cairo_image_surface_get_width(surf);
+    int height = cairo_image_surface_get_height(surf);
+    uint8_t *dest_line;
+    uint8_t *dest_line_end;
+    uint8_t *src_line;
+    int dest_stride;
+    int src_stride;
+
+    ASSERT(cairo_image_surface_get_format(surf) == CAIRO_FORMAT_RGB24);
+    cairo_surface_t *invers = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
+
+    if (cairo_surface_status(invers) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(invers)));
+    }
+
+    dest_line = cairo_image_surface_get_data(invers);
+    dest_stride = cairo_image_surface_get_stride(invers);
+    dest_line_end = dest_line + dest_stride * height;
+    src_line = cairo_image_surface_get_data(surf);
+    src_stride = cairo_image_surface_get_stride(surf);
+
+    for (; dest_line != dest_line_end; dest_line += dest_stride, src_line += src_stride) {
+        uint32_t *src = (uint32_t *)src_line;
+        uint32_t *dest = (uint32_t *)dest_line;
+        uint32_t *end = dest + width;
+        while (dest < end) {
+            *(dest++) = ~*(src++) & 0x00ffffff;
+        }
+    }
+    return invers;
+}
+
+/*
+* Return the inversed surface and assigns it to the user data of the given surface.
+* The routine also handles the reference count of the inversed surface. It you don't use
+* the returned reference, you must call cairo_surface_destroy.
+* Thread safe with respect to the user data.
+*/
+static inline cairo_surface_t* canvas_handle_inverse_user_data(cairo_surface_t* surface)
+{
+    cairo_surface_t *inv_surf = NULL;
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+    MUTEX_LOCK(cairo_surface_user_data_mutex);
+#endif
+    inv_surf = (cairo_surface_t *)cairo_surface_get_user_data(surface, &invers_data_type);
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+    MUTEX_UNLOCK(cairo_surface_user_data_mutex);
+#endif
+    if (!inv_surf) {
+        if (cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A1) {
+            inv_surf = canvas_A1_invers(surface);
+        } else {
+            inv_surf = canvas_surf_to_invers(surface);
+        }
+
+        if (cairo_surface_status(inv_surf) != CAIRO_STATUS_SUCCESS) {
+            cairo_surface_destroy(inv_surf);
+            CANVAS_ERROR("create surface failed, %s",
+                         cairo_status_to_string(cairo_surface_status(surface)));
+        }
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+        MUTEX_LOCK(cairo_surface_user_data_mutex);
+
+        // checking if other thread has already assigned the user data
+        if (!cairo_surface_get_user_data(surface, &invers_data_type)) {
+#endif
+            if (cairo_surface_set_user_data(surface, &invers_data_type, inv_surf,
+                                            __release_surface) == CAIRO_STATUS_SUCCESS) {
+                cairo_surface_reference(inv_surf);
+            }
+#ifdef CAIRO_CANVAS_CACH_IS_SHARED
+        }
+        MUTEX_UNLOCK(cairo_surface_user_data_mutex);
+#endif
+    } else {
+        cairo_surface_reference(inv_surf);
+    }
+
+    return inv_surf;
+}
+
+static cairo_surface_t *canvas_get_mask(CanvasBase *canvas, QMask *mask)
+{
+    ImageDescriptor *descriptor;
+    cairo_surface_t *surface;
+    int need_invers;
+    int is_invers;
+    int cache_me;
+
+    if (!mask->bitmap) {
+        return NULL;
+    }
+
+    descriptor = (ImageDescriptor *)GET_ADDRESS(mask->bitmap);
+    access_test(canvas, descriptor, sizeof(ImageDescriptor));
+    need_invers = mask->flags & MASK_INVERS;
+
+#ifdef CAIRO_CANVAS_CACHE
+    cache_me = descriptor->flags & IMAGE_CACHE_ME;
+#else
+    cache_me = 0;
+#endif
+
+    switch (descriptor->type) {
+    case IMAGE_TYPE_BITMAP: {
+        BitmapImage *bitmap = (BitmapImage *)descriptor;
+        access_test(canvas, descriptor, sizeof(BitmapImage));
+        is_invers = need_invers && !cache_me;
+        surface = canvas_get_bitmap_mask(canvas, &bitmap->bitmap, is_invers);
+        break;
+    }
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+    case IMAGE_TYPE_FROM_CACHE:
+        surface = canvas->bits_cache_get(canvas->bits_cache_opaque, descriptor->id);
+        is_invers = 0;
+        break;
+#endif
+    default:
+        CANVAS_ERROR("invalid image type");
+    }
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+    if (cache_me) {
+        canvas->bits_cache_put(canvas->bits_cache_opaque, descriptor->id, surface);
+    }
+
+    if (need_invers && !is_invers) { // surface is in cache
+        cairo_surface_t *inv_surf;
+
+        inv_surf = canvas_handle_inverse_user_data(surface);
+
+        cairo_surface_destroy(surface);
+        surface = inv_surf;
+    }
+#endif
+    return surface;
+}
+
+static inline RasterGlyph *canvas_next_raster_glyph(const RasterGlyph *glyph, int bpp)
+{
+    return (RasterGlyph *)((uint8_t *)(glyph + 1) +
+                                          (ALIGN(glyph->width * bpp, 8) * glyph->height >> 3));
+}
+
+static inline void canvas_raster_glyph_box(const RasterGlyph *glyph, Rect *r)
+{
+    ASSERT(r);
+    r->top = glyph->render_pos.y + glyph->glyph_origin.y;
+    r->bottom = r->top + glyph->height;
+    r->left = glyph->render_pos.x + glyph->glyph_origin.x;
+    r->right = r->left + glyph->width;
+}
+
+#ifdef GL_CANVAS
+static inline void __canvas_put_bits(uint8_t *dest, int offset, uint8_t val, int n)
+{
+    uint8_t mask;
+    int now;
+
+    dest = dest + (offset >> 3);
+    offset &= 0x07;
+    now = MIN(8 - offset, n);
+
+    mask = ~((1 << (8 - now)) - 1);
+    mask >>= offset;
+    *dest = ((val >> offset) & mask) | *dest;
+
+    if ((n = n - now)) {
+        mask = ~((1 << (8 - n)) - 1);
+        dest++;
+        *dest = ((val << now) & mask) | *dest;
+    }
+}
+
+#else
+static inline void __canvas_put_bits(uint8_t *dest, int offset, uint8_t val, int n)
+{
+    uint8_t mask;
+    int now;
+
+    dest = dest + (offset >> 3);
+    offset &= 0x07;
+
+    now = MIN(8 - offset, n);
+
+    mask = (1 << now) - 1;
+    mask <<= offset;
+    val = revers_bits(val);
+    *dest = ((val << offset) & mask) | *dest;
+
+    if ((n = n - now)) {
+        mask = (1 << n) - 1;
+        dest++;
+        *dest = ((val >> now) & mask) | *dest;
+    }
+}
+
+#endif
+
+static inline void canvas_put_bits(uint8_t *dest, int dest_offset, uint8_t *src, int n)
+{
+    while (n) {
+        int now = MIN(n, 8);
+
+        n -= now;
+        __canvas_put_bits(dest, dest_offset, *src, now);
+        dest_offset += now;
+        src++;
+    }
+}
+
+static void canvas_put_glyph_bits(RasterGlyph *glyph, int bpp, uint8_t *dest, int dest_stride,
+                                  Rect *bounds)
+{
+    Rect glyph_box;
+    uint8_t *src;
+    int lines;
+    int width;
+
+    //todo: support STRING_RASTER_TOP_DOWN
+    canvas_raster_glyph_box(glyph, &glyph_box);
+    ASSERT(glyph_box.top >= bounds->top && glyph_box.bottom <= bounds->bottom);
+    ASSERT(glyph_box.left >= bounds->left && glyph_box.right <= bounds->right);
+    rect_offset(&glyph_box, -bounds->left, -bounds->top);
+
+    dest += glyph_box.top * dest_stride;
+    src = glyph->data;
+    lines = glyph_box.bottom - glyph_box.top;
+    width = glyph_box.right - glyph_box.left;
+    switch (bpp) {
+    case 1: {
+        int src_stride = ALIGN(width, 8) >> 3;
+        int i;
+
+        src += src_stride * (lines);
+        for (i = 0; i < lines; i++) {
+            src -= src_stride;
+            canvas_put_bits(dest, glyph_box.left, src, width);
+            dest += dest_stride;
+        }
+        break;
+    }
+    case 4: {
+        uint8_t *end;
+        int src_stride = ALIGN(width * 4, 8) >> 3;
+
+        src += src_stride * lines;
+        dest += glyph_box.left;
+        end = dest + dest_stride * lines;
+        for (; dest != end; dest += dest_stride) {
+            int i = 0;
+            uint8_t *now;
+
+            src -= src_stride;
+            now = src;
+            while (i < (width & ~1)) {
+                dest[i] = MAX(dest[i], *now & 0xf0);
+                dest[i + 1] = MAX(dest[i + 1], *now << 4);
+                i += 2;
+                now++;
+            }
+            if (i < width) {
+                dest[i] = MAX(dest[i], *now & 0xf0);
+                now++;
+            }
+        }
+        break;
+    }
+    case 8: {
+        uint8_t *end;
+        src += width * lines;
+        dest += glyph_box.left;
+        end = dest + dest_stride * lines;
+        for (; dest != end; dest += dest_stride, src -= width) {
+            int i;
+
+            for (i = 0; i < width; i++) {
+                dest[i] = MAX(dest[i], src[i]);
+            }
+        }
+        break;
+    }
+    default:
+        CANVAS_ERROR("invalid bpp");
+    }
+}
+
+static cairo_surface_t *canvas_get_str_mask(CanvasBase *canvas, String *str, int bpp, Point *pos)
+{
+    RasterGlyph *glyph = (RasterGlyph *)str->data;
+    RasterGlyph *next_glyph;
+    Rect bounds;
+    cairo_surface_t *str_mask;
+    uint8_t *dest;
+    int dest_stride;
+    int i;
+
+    ASSERT(str->length > 0);
+
+    access_test(canvas, glyph, sizeof(RasterGlyph));
+    next_glyph = canvas_next_raster_glyph(glyph, bpp);
+    access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
+    canvas_raster_glyph_box(glyph, &bounds);
+
+    for (i = 1; i < str->length; i++) {
+        Rect glyph_box;
+
+        glyph = next_glyph;
+        access_test(canvas, glyph, sizeof(RasterGlyph));
+        next_glyph = canvas_next_raster_glyph(glyph, bpp);
+        access_test(canvas, glyph, (uint8_t*)next_glyph - (uint8_t*)glyph);
+        canvas_raster_glyph_box(glyph, &glyph_box);
+        rect_union(&bounds, &glyph_box);
+    }
+
+    str_mask = cairo_image_surface_create((bpp == 1) ? CAIRO_FORMAT_A1 : CAIRO_FORMAT_A8,
+                                          bounds.right - bounds.left,
+                                          bounds.bottom - bounds.top);
+    if (cairo_surface_status(str_mask) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(str_mask)));
+    }
+    dest = cairo_image_surface_get_data(str_mask);
+    dest_stride = cairo_image_surface_get_stride(str_mask);
+    glyph = (RasterGlyph *)str->data;
+    for (i = 0; i < str->length; i++) {
+#if defined(GL_CANVAS)
+        canvas_put_glyph_bits(glyph, bpp, dest + (bounds.bottom - bounds.top - 1) * dest_stride,
+                              -dest_stride, &bounds);
+#else
+        canvas_put_glyph_bits(glyph, bpp, dest, dest_stride, &bounds);
+#endif
+        glyph = canvas_next_raster_glyph(glyph, bpp);
+    }
+
+    pos->x = bounds.left;
+    pos->y = bounds.top;
+    return str_mask;
+}
+
+static inline VectotGlyph *canvas_next_vector_glyph(const VectotGlyph *glyph)
+{
+    return (VectotGlyph *)((uint8_t *)(glyph + 1) + glyph->data_size);
+}
+
+static cairo_surface_t *canvas_scale_surface(cairo_surface_t *src, const Rect *src_area, int width,
+                                             int hight, int scale_mode)
+{
+    cairo_t *cairo;
+    cairo_surface_t *surface;
+    cairo_pattern_t *pattern;
+    cairo_matrix_t matrix;
+    double sx, sy;
+
+    surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, hight);
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+
+    cairo = cairo_create(surface);
+    if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s", cairo_status_to_string(cairo_status(cairo)));
+    }
+
+    pattern = cairo_pattern_create_for_surface(src);
+    if (cairo_pattern_status(pattern) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create pattern failed, %s",
+                     cairo_status_to_string(cairo_pattern_status(pattern)));
+    }
+
+    sx = (double)(src_area->right - src_area->left) / width;
+    sy = (double)(src_area->bottom - src_area->top) / hight;
+
+    cairo_matrix_init_translate(&matrix, src_area->left, src_area->top);
+    cairo_matrix_scale(&matrix, sx, sy);
+
+    cairo_pattern_set_matrix(pattern, &matrix);
+    ASSERT(scale_mode == IMAGE_SCALE_INTERPOLATE || scale_mode == IMAGE_SCALE_NEAREST);
+    cairo_pattern_set_filter(pattern, (scale_mode == IMAGE_SCALE_NEAREST) ?
+                                                          CAIRO_FILTER_NEAREST : CAIRO_FILTER_GOOD);
+
+    cairo_set_source(cairo, pattern);
+    cairo_pattern_destroy(pattern);
+    cairo_paint(cairo);
+    cairo_destroy(cairo);
+    return surface;
+}
+
+static void quic_usr_error(QuicUsrContext *usr, const char *fmt, ...)
+{
+    QuicData *usr_data = (QuicData *)usr;
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+
+    longjmp(usr_data->jmp_env, 1);
+}
+
+static void quic_usr_warn(QuicUsrContext *usr, const char *fmt, ...)
+{
+    QuicData *usr_data = (QuicData *)usr;
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+}
+
+static void *quic_usr_malloc(QuicUsrContext *usr, int size)
+{
+    return malloc(size);
+}
+
+static void quic_usr_free(QuicUsrContext *usr, void *ptr)
+{
+    free(ptr);
+}
+
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+
+static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
+{
+    return 0;
+}
+
+static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
+{
+    LzData *usr_data = (LzData *)usr;
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+}
+
+static void lz_usr_error(LzUsrContext *usr, const char *fmt, ...)
+{
+    LzData *usr_data = (LzData *)usr;
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+
+    longjmp(usr_data->jmp_env, 1);
+}
+
+static void *lz_usr_malloc(LzUsrContext *usr, int size)
+{
+    return malloc(size);
+}
+
+static void lz_usr_free(LzUsrContext *usr, void *ptr)
+{
+    free(ptr);
+}
+
+static int lz_usr_more_space(LzUsrContext *usr, uint8_t **io_ptr)
+{
+    return 0;
+}
+
+static int lz_usr_more_lines(LzUsrContext *usr, uint8_t **lines)
+{
+    return 0;
+}
+
+#else
+
+static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
+{
+    QuicData *quic_data = (QuicData *)usr;
+    DataChunk *chunk;
+
+    if (!quic_data->next) {
+        return 0;
+    }
+    chunk = (DataChunk *)GET_ADDRESS(quic_data->next + quic_data->address_delta);
+    quic_data->next = chunk->next;
+    *io_ptr = (uint32_t *)chunk->data;
+    return chunk->size >> 2;
+}
+
+#endif
+
+static int quic_usr_more_lines(QuicUsrContext *usr, uint8_t **lines)
+{
+    return 0;
+}
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+static void __canvas_set_access_params(CanvasBase *canvas, ADDRESS delta, unsigned long base,
+                                       unsigned long max)
+{
+    canvas->address_delta = delta;
+    canvas->base = base;
+    canvas->max = max;
+}
+
+#else
+static void __canvas_set_access_params(CanvasBase *canvas, ADDRESS delta)
+{
+    canvas->address_delta = delta;
+}
+
+#endif
+
+static void canvas_base_destroy(CanvasBase *canvas)
+{
+    quic_destroy(canvas->quic_data.quic);
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+    lz_destroy(canvas->lz_data.lz);
+#endif
+#ifdef GDI_CANVAS
+    DeleteDC(canvas->dc);
+#endif
+}
+
+#ifdef CAIRO_CANVAS_CACHE
+static int canvas_base_init(CanvasBase *canvas, int depth,
+                            void *bits_cache_opaque,
+                            bits_cache_put_fn_t bits_cache_put,
+                            bits_cache_get_fn_t bits_cache_get,
+                            void *palette_cache_opaque,
+                            palette_cache_put_fn_t palette_cache_put,
+                            palette_cache_get_fn_t palette_cache_get,
+                            palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+static int canvas_base_init(CanvasBase *canvas, int depth,
+                            void *bits_cache_opaque,
+                            bits_cache_put_fn_t bits_cache_put,
+                            bits_cache_get_fn_t bits_cache_get
+#else
+static int canvas_base_init(CanvasBase *canvas, int depth
+#endif
+#ifdef USE_GLZ
+                            , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                            )
+{
+    canvas->quic_data.usr.error = quic_usr_error;
+    canvas->quic_data.usr.warn = quic_usr_warn;
+    canvas->quic_data.usr.info = quic_usr_warn;
+    canvas->quic_data.usr.malloc = quic_usr_malloc;
+    canvas->quic_data.usr.free = quic_usr_free;
+    canvas->quic_data.usr.more_space = quic_usr_more_space;
+    canvas->quic_data.usr.more_lines = quic_usr_more_lines;
+    if (!(canvas->quic_data.quic = quic_create(&canvas->quic_data.usr))) {
+            return 0;
+    }
+#ifdef CAIRO_CANVAS_NO_CHUNKS
+    canvas->lz_data.usr.error = lz_usr_error;
+    canvas->lz_data.usr.warn = lz_usr_warn;
+    canvas->lz_data.usr.info = lz_usr_warn;
+    canvas->lz_data.usr.malloc = lz_usr_malloc;
+    canvas->lz_data.usr.free = lz_usr_free;
+    canvas->lz_data.usr.more_space = lz_usr_more_space;
+    canvas->lz_data.usr.more_lines = lz_usr_more_lines;
+    if (!(canvas->lz_data.lz = lz_create(&canvas->lz_data.usr))) {
+            return 0;
+    }
+#endif
+#ifdef USE_GLZ
+    canvas->glz_data.decoder_opaque = glz_decoder_opaque;
+    canvas->glz_data.decode = glz_decode;
+#endif
+
+    if (depth == 16) {
+        canvas->color_shift = 5;
+        canvas->color_mask = 0x1f;
+    } else {
+        canvas->color_shift = 8;
+        canvas->color_mask = 0xff;
+    }
+
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+    canvas->bits_cache_opaque = bits_cache_opaque;
+    canvas->bits_cache_put = bits_cache_put;
+    canvas->bits_cache_get = bits_cache_get;
+#endif
+#ifdef CAIRO_CANVAS_CACHE
+    canvas->palette_cache_opaque = palette_cache_opaque;
+    canvas->palette_cache_put = palette_cache_put;
+    canvas->palette_cache_get = palette_cache_get;
+    canvas->palette_cache_release = palette_cache_release;
+#endif
+
+#ifdef WIN32
+    canvas->dc = NULL;
+#endif
+
+#ifdef GDI_CANVAS
+    canvas->dc = create_compatible_dc();
+    if (!canvas->dc) {
+        lz_destroy(canvas->lz_data.lz);
+        return 0;
+    }
+#endif
+    return 1;
+}
+
diff --git a/common/canvas_base.h b/common/canvas_base.h
new file mode 100644
index 00000000..778244f7
--- /dev/null
+++ b/common/canvas_base.h
@@ -0,0 +1,40 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CANVAS_BASE
+#define _H_CANVAS_BASE
+
+
+#include "cairo.h"
+#include "lz.h"
+#include "draw.h"
+
+#if defined(CAIRO_CANVAS_CACHE) || defined(CAIRO_CANVAS_IMAGE_CACHE)
+typedef void (*bits_cache_put_fn_t)(void *bits_cache_opaque, uint64_t id, cairo_surface_t *surface);
+typedef cairo_surface_t *(*bits_cache_get_fn_t)(void *bits_cache_opaque, uint64_t id);
+#endif
+#ifdef CAIRO_CANVAS_CACHE
+typedef void (*palette_cache_put_fn_t)(void *palette_cache_opaque, Palette *palette);
+typedef Palette *(*palette_cache_get_fn_t)(void *palette_cache_opaque, uint64_t id);
+typedef void (*palette_cache_release_fn_t)(Palette *palette);
+#endif
+
+typedef void (*glz_decode_fn_t)(void *glz_decoder_opaque, uint8_t *data,
+                                Palette *plt, void *usr_data);
+
+#endif
+
diff --git a/common/canvas_utils.c b/common/canvas_utils.c
new file mode 100644
index 00000000..f6470cae
--- /dev/null
+++ b/common/canvas_utils.c
@@ -0,0 +1,277 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "canvas_utils.h"
+
+#ifdef __GNUC__
+#include <stdlib.h>
+#include <stdio.h>
+#endif
+
+#ifdef WIN32
+extern int gdi_handlers;
+#endif
+
+#ifndef ASSERT
+#define ASSERT(x) if (!(x)) {                               \
+    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
+    abort();                                                \
+}
+#endif
+
+
+#ifndef CANVAS_ERROR
+#define CANVAS_ERROR(format, ...) {                             \
+    printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__);   \
+    abort();                                                    \
+}
+#endif
+
+#ifndef ALIGN
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+#endif
+
+const cairo_user_data_key_t bitmap_data_type = {0};
+const cairo_user_data_key_t bitmap_withstride_data_type = {0};
+
+#ifdef WIN32
+static void release_bitmap(void *bitmap_cache)
+{
+    DeleteObject((HBITMAP)((BitmapCache *)bitmap_cache)->bitmap);
+    CloseHandle(((BitmapCache *)bitmap_cache)->mutex);
+    free(bitmap_cache);
+    gdi_handlers--;
+}
+
+#endif
+
+static void release_withstride_bitmap(void *data)
+{
+    free(data);
+}
+
+static inline cairo_surface_t *__surface_create_stride(cairo_format_t format, int width, int height,
+                                                       int stride)
+{
+    uint8_t *data;
+    uint8_t *stride_data;
+    cairo_surface_t *surface;
+
+    data = (uint8_t *)malloc(abs(stride) * height);
+    if (stride < 0) {
+        stride_data = data + (-stride) * (height - 1);
+    } else {
+        stride_data = data;
+    }
+
+    surface = cairo_image_surface_create_for_data(stride_data, format, width, height, stride);
+
+    if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+        free(data);
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+
+    if (cairo_surface_set_user_data(surface, &bitmap_withstride_data_type, data,
+                                    release_withstride_bitmap) != CAIRO_STATUS_SUCCESS) {
+        free(data);
+        cairo_surface_destroy(surface);
+        CANVAS_ERROR("set_user_data surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(surface)));
+    }
+
+    return surface;
+}
+
+#ifdef WIN32
+cairo_surface_t *surface_create(HDC dc, cairo_format_t format,
+                                int width, int height, int top_down)
+#else
+cairo_surface_t * surface_create(cairo_format_t format, int width, int height, int top_down)
+#endif
+{
+#ifdef WIN32
+    /*
+     * Windows xp allow only 10,000 of gdi handlers, considering the fact that
+     * we limit here the number to 5000, we dont use atomic operations to sync
+     * this calculation against the other canvases (in case of multiple
+     * monitors), in worst case there will be little more than 5000 gdi
+     * handlers.
+     */
+    if (dc && gdi_handlers < 5000) {
+        uint8_t *data;
+        uint8_t *src;
+        struct {
+            BITMAPINFO inf;
+            RGBQUAD palette[255];
+        } bitmap_info;
+        int nstride;
+        cairo_surface_t *surface;
+        BitmapCache *bitmap_cache;
+
+        memset(&bitmap_info, 0, sizeof(bitmap_info));
+        bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+        bitmap_info.inf.bmiHeader.biWidth = width;
+
+        bitmap_info.inf.bmiHeader.biHeight = (!top_down) ? height : -height;
+
+        bitmap_info.inf.bmiHeader.biPlanes = 1;
+        switch (format) {
+        case CAIRO_FORMAT_ARGB32:
+        case CAIRO_FORMAT_RGB24:
+            bitmap_info.inf.bmiHeader.biBitCount = 32;
+            nstride = width * 4;
+            break;
+        case CAIRO_FORMAT_A8:
+            bitmap_info.inf.bmiHeader.biBitCount = 8;
+            nstride = ALIGN(width, 4);
+            break;
+        case CAIRO_FORMAT_A1:
+            bitmap_info.inf.bmiHeader.biBitCount = 1;
+            nstride = ALIGN(width, 32) / 8;
+            break;
+        default:
+            CANVAS_ERROR("invalid format");
+        }
+
+        bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+
+        bitmap_cache = (BitmapCache *)malloc(sizeof(*bitmap_cache));
+        if (!bitmap_cache) {
+            CANVAS_ERROR("malloc failed");
+            return NULL;
+        }
+
+        bitmap_cache->mutex = CreateMutex(NULL, 0, NULL);
+        if (!bitmap_cache->mutex) {
+            free(bitmap_cache);
+            CANVAS_ERROR("Unable to CreateMutex");
+            return NULL;
+        }
+
+        bitmap_cache->bitmap = CreateDIBSection(dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
+        if (!bitmap_cache->bitmap) {
+            CloseHandle(bitmap_cache->mutex);
+            free(bitmap_cache);
+            CANVAS_ERROR("Unable to CreateDIBSection");
+            return NULL;
+        }
+
+        if (top_down) {
+            src = data;
+        } else {
+            src = data + nstride * (height - 1);
+            nstride = -nstride;
+        }
+
+        surface = cairo_image_surface_create_for_data(src, format, width, height, nstride);
+        if (cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {
+            CloseHandle(bitmap_cache->mutex);
+            DeleteObject((HBITMAP)bitmap_cache->bitmap);
+            free(bitmap_cache);
+            CANVAS_ERROR("create surface failed, %s",
+                         cairo_status_to_string(cairo_surface_status(surface)));
+        }
+        if (cairo_surface_set_user_data(surface, &bitmap_data_type, bitmap_cache,
+                                        release_bitmap) != CAIRO_STATUS_SUCCESS) {
+            CloseHandle(bitmap_cache->mutex);
+            cairo_surface_destroy(surface);
+            DeleteObject((HBITMAP)bitmap_cache->bitmap);
+            free(bitmap_cache);
+            CANVAS_ERROR("set_user_data surface failed, %s",
+                         cairo_status_to_string(cairo_surface_status(surface)));
+        }
+        gdi_handlers++;
+        return surface;
+    } else {
+#endif
+    if (top_down) {
+        return cairo_image_surface_create(format, width, height);
+    } else {
+        // NOTE: we assume here that the lz decoders always decode to RGB32.
+        int stride = 0;
+        switch (format) {
+        case CAIRO_FORMAT_ARGB32:
+        case CAIRO_FORMAT_RGB24:
+            stride = width * 4;
+            break;
+        case CAIRO_FORMAT_A8:
+            stride = ALIGN(width, 4);
+            break;
+        case CAIRO_FORMAT_A1:
+            stride = ALIGN(width, 32) / 8;
+            break;
+        default:
+            CANVAS_ERROR("invalid format");
+        }
+        stride = -stride;
+        return __surface_create_stride(format, width, height, stride);
+    }
+#ifdef WIN32
+}
+
+#endif
+}
+
+#ifdef WIN32
+cairo_surface_t *surface_create_stride(HDC dc, cairo_format_t format, int width, int height,
+                                       int stride)
+#else
+cairo_surface_t *surface_create_stride(cairo_format_t format, int width, int height,
+                                        int stride)
+#endif
+{
+#ifdef WIN32
+    if (dc) {
+        if (abs(stride) == (width * 4)) {
+            return surface_create(dc, format, width, height, (stride > 0));
+        }
+    }
+#endif
+
+    return __surface_create_stride(format, width, height, stride);
+}
+
+cairo_surface_t *alloc_lz_image_surface(LzDecodeUsrData *canvas_data, LzImageType type, int width,
+                                        int height, int gross_pixels, int top_down)
+{
+    int stride;
+    int alpha;
+    cairo_surface_t *surface = NULL;
+
+    stride = (gross_pixels / height) * 4;
+
+    if (!top_down) {
+        stride = -stride;
+    }
+
+    if (type == LZ_IMAGE_TYPE_RGB32) {
+        alpha = 0;
+    } else if (type == LZ_IMAGE_TYPE_RGBA) {
+        alpha = 1;
+    } else {
+        CANVAS_ERROR("unexpected image type");
+    }
+    surface = surface_create_stride(
+#ifdef WIN32
+            canvas_data->dc,
+#endif
+            alpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24, width, height, stride);
+    canvas_data->out_surface = surface;
+    return surface;
+}
+
diff --git a/common/canvas_utils.h b/common/canvas_utils.h
new file mode 100644
index 00000000..8ccc3044
--- /dev/null
+++ b/common/canvas_utils.h
@@ -0,0 +1,67 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_CANVAS_UTILS
+#define _H_CANVAS_UTILS
+
+#ifdef __GNUC__
+#include <stdint.h>
+#else
+#include <stddef.h>
+#include <basetsd.h>
+typedef UINT8 uint8_t;
+#endif  //__GNUC__
+
+#include "cairo.h"
+#include "lz.h"
+
+#ifdef WIN32
+typedef struct BitmapCache {
+    HBITMAP bitmap;
+    HANDLE mutex;
+} BitmapCache;
+#endif
+
+extern const cairo_user_data_key_t bitmap_data_type;
+
+#ifdef WIN32
+cairo_surface_t *surface_create(HDC dc, cairo_format_t format,
+                                int width, int height, int top_down);
+#else
+cairo_surface_t *surface_create(cairo_format_t format, int width, int height, int top_down);
+#endif
+
+#ifdef WIN32
+cairo_surface_t *surface_create_stride(HDC dc, cairo_format_t format, int width, int height,
+                                       int stride);
+#else
+cairo_surface_t *surface_create_stride(cairo_format_t format, int width, int height,
+                                       int stride);
+#endif
+
+
+typedef struct LzDecodeUsrData {
+#ifdef WIN32
+    HDC dc;
+#endif
+    cairo_surface_t       *out_surface;
+} LzDecodeUsrData;
+
+
+cairo_surface_t *alloc_lz_image_surface(LzDecodeUsrData *canvas_data, LzImageType type, int width,
+                                        int height, int gross_pixels, int top_down);
+#endif
diff --git a/common/draw.h b/common/draw.h
new file mode 100644
index 00000000..e277b2d9
--- /dev/null
+++ b/common/draw.h
@@ -0,0 +1,406 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_DRAW
+#define _H_DRAW
+
+#ifndef _WIN32
+#include <stdint.h>
+#endif
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+typedef uint64_t UINT64;
+typedef uint32_t UINT32;
+typedef uint16_t UINT16;
+typedef uint8_t UINT8;
+
+typedef int16_t INT16;
+typedef int32_t INT32;
+#else
+#include <basetsd.h>
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#pragma warning(disable:4200)
+#endif
+
+#ifdef _WIN32_WCE
+#include <stdint.h>
+typedef uint64_t UINT64;
+typedef uint32_t UINT32;
+typedef uint16_t UINT16;
+typedef uint8_t UINT8;
+
+typedef int16_t INT16;
+typedef int32_t INT32;
+#endif
+
+#define GET_ADDRESS(addr) ((void *)(unsigned long)(addr))
+#define SET_ADDRESS(addr, val) ((addr) = (unsigned long)(val))
+
+typedef INT32 FIXED28_4;
+typedef UINT64 ADDRESS;
+
+enum {
+    PATH_BEGIN = (1 << 0),
+    PATH_END = (1 << 1),
+    PATH_CLOSE = (1 << 3),
+    PATH_BEZIER = (1 << 4),
+};
+
+enum {
+    LINE_ATTR_STARTGAP = (1 << 2),
+    LINE_ATTR_STYLED = (1 << 3),
+};
+
+typedef struct ATTR_PACKED PointFix {
+    FIXED28_4 x;
+    FIXED28_4 y;
+} PointFix;
+
+typedef struct ATTR_PACKED Point {
+    INT32 x;
+    INT32 y;
+} Point;
+
+typedef struct ATTR_PACKED Point16 {
+    INT16 x;
+    INT16 y;
+} Point16;
+
+typedef struct ATTR_PACKED Rect {
+    INT32 top;
+    INT32 left;
+    INT32 bottom;
+    INT32 right;
+} Rect;
+
+typedef struct ATTR_PACKED PathSeg {
+    UINT32 flags;
+    UINT32 count;
+    UINT8 data[0];
+} PathSeg;
+
+enum ClipType {
+    CLIP_TYPE_NONE,
+    CLIP_TYPE_RECTS,
+    CLIP_TYPE_PATH,
+};
+
+typedef struct ATTR_PACKED Clip {
+    UINT32 type;
+    ADDRESS data;
+} Clip;
+
+enum ROPDescriptor {
+    ROPD_INVERS_SRC = (1 << 0),
+    ROPD_INVERS_BRUSH = (1 << 1),
+    ROPD_INVERS_DEST = (1 << 2),
+    ROPD_OP_PUT = (1 << 3),
+    ROPD_OP_OR = (1 << 4),
+    ROPD_OP_AND = (1 << 5),
+    ROPD_OP_XOR = (1 << 6),
+    ROPD_OP_BLACKNESS = (1 << 7),
+    ROPD_OP_WHITENESS = (1 << 8),
+    ROPD_OP_INVERS = (1 << 9),
+    ROPD_INVERS_RES = (1 << 10),
+};
+
+typedef struct ATTR_PACKED Pattern {
+    ADDRESS pat;
+    Point pos;
+} Pattern;
+
+enum {
+    BRUSH_TYPE_NONE,
+    BRUSH_TYPE_SOLID,
+    BRUSH_TYPE_PATTERN,
+};
+
+typedef struct ATTR_PACKED Brush {
+    UINT32 type;
+    union {
+        UINT32 color;
+        Pattern pattern;
+    } u;
+} Brush;
+
+enum {
+    MASK_INVERS = (1 << 0),
+};
+
+typedef struct ATTR_PACKED QMask {
+    UINT8 flags;
+    Point pos;
+    ADDRESS bitmap;
+} QMask;
+
+typedef struct ATTR_PACKED Fill {
+    Brush brush;
+    UINT16 rop_decriptor;
+    QMask mask;
+} Fill;
+
+typedef struct ATTR_PACKED Palette {
+    UINT64 unique;
+    UINT16 num_ents;
+    UINT32 ents[0];
+} Palette;
+
+enum {
+    IMAGE_TYPE_BITMAP,
+    IMAGE_TYPE_QUIC,
+    IMAGE_TYPE_RESERVED,
+    IMAGE_TYPE_LZ_PLT = 100,
+    IMAGE_TYPE_LZ_RGB,
+    IMAGE_TYPE_GLZ_RGB,
+    IMAGE_TYPE_FROM_CACHE,
+};
+
+enum {
+    IMAGE_CACHE_ME = (1 << 0),
+};
+
+typedef struct ATTR_PACKED ImageDescriptor {
+    UINT64 id;
+    UINT8 type;
+    UINT8 flags;
+    UINT32 width;
+    UINT32 height;
+} ImageDescriptor;
+
+enum {
+    BITMAP_FMT_INVALID,
+    BITMAP_FMT_1BIT_LE,
+    BITMAP_FMT_1BIT_BE,
+    BITMAP_FMT_4BIT_LE,
+    BITMAP_FMT_4BIT_BE,
+    BITMAP_FMT_8BIT,
+    BITMAP_FMT_16BIT,
+    BITMAP_FMT_24BIT,
+    BITMAP_FMT_32BIT,
+    BITMAP_FMT_RGBA,
+};
+
+enum {
+    BITMAP_PAL_CACHE_ME = (1 << 0),
+    BITMAP_PAL_FROM_CACHE = (1 << 1),
+    BITMAP_TOP_DOWN = (1 << 2),
+};
+
+typedef struct ATTR_PACKED Bitmap {
+    UINT8 format;
+    UINT8 flags;
+    UINT32 x;
+    UINT32 y;
+    UINT32 stride;
+    ADDRESS palette;
+    ADDRESS data; //data[0] ?
+} Bitmap;
+
+typedef struct ATTR_PACKED BitmapImage {
+    ImageDescriptor descriptor;
+    Bitmap bitmap;
+} BitmapImage;
+
+typedef struct ATTR_PACKED QUICData {
+    UINT32 data_size;
+    UINT8 data[0];
+} QUICData, LZ_RGBData;
+
+typedef struct ATTR_PACKED QUICImage {
+    ImageDescriptor descriptor;
+    QUICData quic;
+} QUICImage;
+
+typedef struct ATTR_PACKED LZ_RGBImage {
+    ImageDescriptor descriptor;
+    LZ_RGBData lz_rgb;
+} LZ_RGBImage;
+
+typedef struct ATTR_PACKED LZ_PLTData {
+    UINT8 flags;
+    UINT32 data_size;
+    ADDRESS palette;
+    UINT8 data[0];
+} LZ_PLTData;
+
+typedef struct ATTR_PACKED LZ_PLTImage {
+    ImageDescriptor descriptor;
+    LZ_PLTData lz_plt;
+} LZ_PLTImage;
+
+enum {
+    IMAGE_SCALE_INTERPOLATE,
+    IMAGE_SCALE_NEAREST,
+};
+
+typedef struct ATTR_PACKED Opaque {
+    ADDRESS src_bitmap;
+    Rect src_area;
+    Brush brush;
+    UINT16 rop_decriptor;
+    UINT8 scale_mode;
+    QMask mask;
+} Opaque;
+
+typedef struct ATTR_PACKED Copy {
+    ADDRESS src_bitmap;
+    Rect src_area;
+    UINT16 rop_decriptor;
+    UINT8 scale_mode;
+    QMask mask;
+} Copy, Blend;
+
+typedef struct ATTR_PACKED Transparent {
+    ADDRESS src_bitmap;
+    Rect src_area;
+    UINT32 src_color;
+    UINT32 true_color;
+} Transparent;
+
+typedef struct ATTR_PACKED AlphaBlnd {
+    UINT8 alpha;
+    ADDRESS src_bitmap;
+    Rect src_area;
+} AlphaBlnd;
+
+typedef struct ATTR_PACKED Rop3 {
+    ADDRESS src_bitmap;
+    Rect src_area;
+    Brush brush;
+    UINT8 rop3;
+    UINT8 scale_mode;
+    QMask mask;
+} Rop3;
+
+typedef struct ATTR_PACKED Blackness {
+    QMask mask;
+} Blackness, Invers, Whiteness;
+
+enum {
+    LINE_STYLED = (1 << 3),
+    LINE_START_WITH_GAP = (1 << 2),
+};
+
+enum {
+    LINE_CAP_ROUND,
+    LINE_CAP_SQUARE,
+    LINE_CAP_BUTT,
+};
+
+enum {
+    LINE_JOIN_ROUND,
+    LINE_JOIN_BEVEL,
+    LINE_JOIN_MITER,
+};
+
+typedef struct ATTR_PACKED LineAttr {
+    UINT8 flags;
+    UINT8 join_style;
+    UINT8 end_style;
+    UINT8 style_nseg;
+    FIXED28_4 width;
+    FIXED28_4 miter_limit;
+    ADDRESS style; //data[0] ?
+} LineAttr;
+
+typedef struct ATTR_PACKED Stroke {
+    ADDRESS path;
+    LineAttr attr;
+    Brush brush;
+    UINT16 fore_mode;
+    UINT16 back_mode;
+} Stroke;
+
+typedef struct ATTR_PACKED RasterGlyph {
+    Point render_pos;
+    Point glyph_origin;
+    UINT16 width;
+    UINT16 height;
+    UINT8 data[0];
+} RasterGlyph;
+
+typedef struct ATTR_PACKED VectotGlyph {
+    Point render_pos;
+    UINT32 data_size;
+    UINT8 data[0]; //PathSeg[]
+} VectotGlyph;
+
+enum {
+    STRING_RASTER_A1 = 1 << 0,
+    STRING_RASTER_A4 = 1 << 1,
+    STRING_RASTER_A8 = 1 << 2,
+    STRING_RASTER_TOP_DOWN = 1 << 3,
+};
+
+typedef struct ATTR_PACKED String {
+    UINT16 length;
+    UINT16 flags;
+    UINT8 data[0];
+} String;
+
+typedef struct ATTR_PACKED Text {
+    ADDRESS str;
+    Rect back_area;
+    Brush fore_brush;
+    Brush back_brush;
+    UINT16 fore_mode;
+    UINT16 back_mode;
+} Text;
+
+enum {
+    CURSOR_TYPE_ALPHA,
+    CURSOR_TYPE_MONO,
+    CURSOR_TYPE_COLOR4,
+    CURSOR_TYPE_COLOR8,
+    CURSOR_TYPE_COLOR16,
+    CURSOR_TYPE_COLOR24,
+    CURSOR_TYPE_COLOR32,
+};
+
+typedef struct ATTR_PACKED CursorHeader {
+    UINT64 unique;
+    UINT16 type;
+    UINT16 width;
+    UINT16 height;
+    UINT16 hot_spot_x;
+    UINT16 hot_spot_y;
+} CursorHeader;
+
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#endif
diff --git a/common/gdi_canvas.c b/common/gdi_canvas.c
new file mode 100644
index 00000000..99079f56
--- /dev/null
+++ b/common/gdi_canvas.c
@@ -0,0 +1,1757 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <Windows.h>
+#include <Wingdi.h>
+#include "gdi_canvas.h"
+#define GDI_CANVAS
+#include "canvas_base.c"
+#include "rop3.h"
+#include "rect.h"
+#include "region.h"
+#include "threads.h"
+
+struct GdiCanvas {
+    CanvasBase base;
+    HDC dc;
+    Mutex* lock;
+};
+
+
+struct BitmapData {
+    HBITMAP hbitmap;
+    HBITMAP prev_hbitmap;
+    Point pos;
+    uint8_t flags;
+    HDC dc;
+    int cache;
+};
+
+#define _rop3_brush 0xf0
+#define _rop3_src 0xcc
+#define _rop3_dest 0xaa
+
+uint32_t raster_ops[] = {
+    0x00000042,
+    0x00010289,
+    0x00020C89,
+    0x000300AA,
+    0x00040C88,
+    0x000500A9,
+    0x00060865,
+    0x000702C5,
+    0x00080F08,
+    0x00090245,
+    0x000A0329,
+    0x000B0B2A,
+    0x000C0324,
+    0x000D0B25,
+    0x000E08A5,
+    0x000F0001,
+    0x00100C85,
+    0x001100A6,
+    0x00120868,
+    0x001302C8,
+    0x00140869,
+    0x001502C9,
+    0x00165CCA,
+    0x00171D54,
+    0x00180D59,
+    0x00191CC8,
+    0x001A06C5,
+    0x001B0768,
+    0x001C06CA,
+    0x001D0766,
+    0x001E01A5,
+    0x001F0385,
+    0x00200F09,
+    0x00210248,
+    0x00220326,
+    0x00230B24,
+    0x00240D55,
+    0x00251CC5,
+    0x002606C8,
+    0x00271868,
+    0x00280369,
+    0x002916CA,
+    0x002A0CC9,
+    0x002B1D58,
+    0x002C0784,
+    0x002D060A,
+    0x002E064A,
+    0x002F0E2A,
+    0x0030032A,
+    0x00310B28,
+    0x00320688,
+    0x00330008,
+    0x003406C4,
+    0x00351864,
+    0x003601A8,
+    0x00370388,
+    0x0038078A, // PSDPoax
+    0x00390604, // SPDnox
+    0x003A0644, // SPDSxox
+    0x003B0E24, // SPDnoan
+    0x003C004A, // PSx
+    0x003D18A4, // SPDSonox
+    0x003E1B24, // SPDSnaox
+    0x003F00EA, // PSan
+    0x00400F0A, // PSDnaa
+    0x00410249, // DPSxon
+    0x00420D5D, // SDxPDxa
+    0x00431CC4, // SPDSanaxn
+    0x00440328, // SDna SRCERASE
+    0x00450B29, // DPSnaon
+    0x004606C6, // DSPDaox
+    0x0047076A, // PSDPxaxn
+    0x00480368, // SDPxa
+    0x004916C5, // PDSPDaoxxn
+    0x004A0789, // DPSDoax
+    0x004B0605, // PDSnox
+    0x004C0CC8, // SDPana
+    0x004D1954, // SSPxDSxoxn
+    0x004E0645, // PDSPxox
+    0x004F0E25, // PDSnoan
+    0x00500325, // PDna
+    0x00510B26, // DSPnaon
+    0x005206C9, // DPSDaox
+    0x00530764, // SPDSxaxn
+    0x005408A9, // DPSonon
+    0x00550009, // Dn DSTINVERT
+    0x005601A9, // DPSox
+    0x00570389, // DPSoan
+    0x00580785, // PDSPoax
+    0x00590609, // DPSnox
+    0x005A0049, // DPx PATINVERT
+    0x005B18A9, // DPSDonox
+    0x005C0649, // DPSDxox
+    0x005D0E29, // DPSnoan
+    0x005E1B29, // DPSDnaox
+    0x005F00E9, // DPan
+    0x00600365, // PDSxa
+    0x006116C6, // DSPDSaoxxn
+    0x00620786, // DSPDoax
+    0x00630608, // SDPnox
+    0x00640788, // SDPSoax
+    0x00650606, // DSPnox
+    0x00660046, // DSx SRCINVERT
+    0x006718A8, // SDPSonox
+    0x006858A6, // DSPDSonoxxn
+    0x00690145, // PDSxxn
+    0x006A01E9, // DPSax
+    0x006B178A, // PSDPSoaxxn
+    0x006C01E8, // SDPax
+    0x006D1785, // PDSPDoaxxn
+    0x006E1E28, // SDPSnoax
+    0x006F0C65, // PDSxnan
+    0x00700CC5, // PDSana
+    0x00711D5C, // SSDxPDxaxn
+    0x00720648, // SDPSxox
+    0x00730E28, // SDPnoan
+    0x00740646, // DSPDxox
+    0x00750E26, // DSPnoan
+    0x00761B28, // SDPSnaox
+    0x007700E6, // DSan
+    0x007801E5, // PDSax
+    0x00791786, // DSPDSoaxxn
+    0x007A1E29, // DPSDnoax
+    0x007B0C68, // SDPxnan
+    0x007C1E24, // SPDSnoax
+    0x007D0C69, // DPSxnan
+    0x007E0955, // SPxDSxo
+    0x007F03C9, // DPSaan
+    0x008003E9, // DPSaa
+    0x00810975, // SPxDSxon
+    0x00820C49, // DPSxna
+    0x00831E04, // SPDSnoaxn
+    0x00840C48, // SDPxna
+    0x00851E05, // PDSPnoaxn
+    0x008617A6, // DSPDSoaxx
+    0x008701C5, // PDSaxn
+    0x008800C6, // DSa SRCAND
+    0x00891B08, // SDPSnaoxn
+    0x008A0E06, // DSPnoa
+    0x008B0666, // DSPDxoxn
+    0x008C0E08, // SDPnoa
+    0x008D0668, // SDPSxoxn
+    0x008E1D7C, // SSDxPDxax
+    0x008F0CE5, // PDSanan
+    0x00900C45, // PDSxna
+    0x00911E08, // SDPSnoaxn
+    0x009217A9, // DPSDPoaxx
+    0x009301C4, // SPDaxn
+    0x009417AA, // PSDPSoaxx
+    0x009501C9, // DPSaxn
+    0x00960169, // DPSxx
+    0x0097588A, // PSDPSonoxx
+    0x00981888, // SDPSonoxn
+    0x00990066, // DSxn
+    0x009A0709, // DPSnax
+    0x009B07A8, // SDPSoaxn
+    0x009C0704, // SPDnax
+    0x009D07A6, // DSPDoaxn
+    0x009E16E6, // DSPDSaoxx
+    0x009F0345, // PDSxan
+    0x00A000C9, // DPa
+    0x00A11B05, // PDSPnaoxn
+    0x00A20E09, // DPSnoa
+    0x00A30669, // DPSDxoxn
+    0x00A41885, // PDSPonoxn
+    0x00A50065, // PDxn
+    0x00A60706, // DSPnax
+    0x00A707A5, // PDSPoaxn
+    0x00A803A9, // DPSoa
+    0x00A90189, // DPSoxn
+    0x00AA0029, // D
+    0x00AB0889, // DPSono
+    0x00AC0744, // SPDSxax
+    0x00AD06E9, // DPSDaoxn
+    0x00AE0B06, // DSPnao
+    0x00AF0229, // DPno
+    0x00B00E05, // PDSnoa
+    0x00B10665, // PDSPxoxn
+    0x00B21974, // SSPxDSxox
+    0x00B30CE8, // SDPanan
+    0x00B4070A, // PSDnax
+    0x00B507A9, // DPSDoaxn
+    0x00B616E9, // DPSDPaoxx
+    0x00B70348, // SDPxan
+    0x00B8074A, // PSDPxax
+    0x00B906E6, // DSPDaoxn
+    0x00BA0B09, // DPSnao
+    0x00BB0226, // DSno MERGEPAINT
+    0x00BC1CE4, // SPDSanax
+    0x00BD0D7D, // SDxPDxan
+    0x00BE0269, // DPSxo
+    0x00BF08C9, // DPSano
+    0x00C000CA, // PSa MERGECOPY
+    0x00C11B04, // SPDSnaoxn
+    0x00C21884, // SPDSonoxn
+    0x00C3006A, // PSxn
+    0x00C40E04, // SPDnoa
+    0x00C50664, // SPDSxoxn
+    0x00C60708, // SDPnax
+    0x00C707AA, // PSDPoaxn
+    0x00C803A8, // SDPoa
+    0x00C90184, // SPDoxn
+    0x00CA0749, // DPSDxax
+    0x00CB06E4, // SPDSaoxn
+    0x00CC0020, // S SRCCOPY
+    0x00CD0888, // SDPono
+    0x00CE0B08, // SDPnao
+    0x00CF0224, // SPno
+    0x00D00E0A, // PSDnoa
+    0x00D1066A, // PSDPxoxn
+    0x00D20705, // PDSnax
+    0x00D307A4, // SPDSoaxn
+    0x00D41D78, // SSPxPDxax
+    0x00D50CE9, // DPSanan
+    0x00D616EA, // PSDPSaoxx
+    0x00D70349, // DPSxan
+    0x00D80745, // PDSPxax
+    0x00D906E8, // SDPSaoxn
+    0x00DA1CE9, // DPSDanax
+    0x00DB0D75, // SPxDSxan
+    0x00DC0B04, // SPDnao
+    0x00DD0228, // SDno
+    0x00DE0268, // SDPxo
+    0x00DF08C8, // SDPano
+    0x00E003A5, // PDSoa
+    0x00E10185, // PDSoxn
+    0x00E20746, // DSPDxax
+    0x00E306EA, // PSDPaoxn
+    0x00E40748, // SDPSxax
+    0x00E506E5, // PDSPaoxn
+    0x00E61CE8, // SDPSanax
+    0x00E70D79, // SPxPDxan
+    0x00E81D74, // SSPxDSxax
+    0x00E95CE6, // DSPDSanaxxn
+    0x00EA02E9, // DPSao
+    0x00EB0849, // DPSxno
+    0x00EC02E8, // SDPao
+    0x00ED0848, // SDPxno
+    0x00EE0086, // DSo SRCPAINT
+    0x00EF0A08, // SDPnoo
+    0x00F00021, // P PATCOPY
+    0x00F10885, // PDSono
+    0x00F20B05, // PDSnao
+    0x00F3022A, // PSno
+    0x00F40B0A, // PSDnao
+    0x00F50225, // PDno
+    0x00F60265, // PDSxo
+    0x00F708C5, // PDSano
+    0x00F802E5, // PDSao
+    0x00F90845, // PDSxno
+    0x00FA0089, // DPo
+    0x00FB0A09, // DPSnoo PATPAINT
+    0x00FC008A, // PSo
+    0x00FD0A0A, // PSDnoo
+    0x00FE02A9, // DPSoo
+    0x00FF0062 // 1 WHITENESS
+};
+
+static inline void surface_to_image(cairo_surface_t *surface, GdiImage *image)
+{
+    cairo_format_t format = cairo_image_surface_get_format(surface);
+
+    ASSERT(format == CAIRO_FORMAT_ARGB32 || format == CAIRO_FORMAT_RGB24);
+    image->width = cairo_image_surface_get_width(surface);
+    image->height = cairo_image_surface_get_height(surface);
+    image->stride = cairo_image_surface_get_stride(surface);
+    image->pixels = cairo_image_surface_get_data(surface);
+}
+
+static void set_path(GdiCanvas *canvas, void *addr)
+{
+    uint32_t* data_size = (uint32_t*)addr;
+    access_test(&canvas->base, data_size, sizeof(uint32_t));
+    uint32_t more = *data_size;
+
+    PathSeg* seg = (PathSeg*)(data_size + 1);
+
+    do {
+        access_test(&canvas->base, seg, sizeof(PathSeg));
+
+        uint32_t flags = seg->flags;
+        PointFix* point = (PointFix*)seg->data;
+        PointFix* end_point = point + seg->count;
+        access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
+        ASSERT(point < end_point);
+        more -= ((unsigned long)end_point - (unsigned long)seg);
+        seg = (PathSeg*)end_point;
+
+        if (flags & PATH_BEGIN) {
+            BeginPath(canvas->dc);
+            if (!MoveToEx(canvas->dc, (int)fix_to_double(point->x), (int)fix_to_double(point->y),
+                          NULL)) {
+                CANVAS_ERROR("MoveToEx failed");
+                return;
+            }
+            point++;
+        }
+
+        if (flags & PATH_BEZIER) {
+            ASSERT((point - end_point) % 3 == 0);
+            for (; point + 2 < end_point; point += 3) {
+                POINT points[3];
+
+                points[0].x = (int)fix_to_double(point[0].x);
+                points[0].y = (int)fix_to_double(point[0].y);
+                points[1].x = (int)fix_to_double(point[1].x);
+                points[1].y = (int)fix_to_double(point[1].y);
+                points[2].x = (int)fix_to_double(point[2].x);
+                points[2].y = (int)fix_to_double(point[2].y);
+                if (!PolyBezierTo(canvas->dc, points, 3)) {
+                    CANVAS_ERROR("PolyBezierTo failed");
+                    return;
+                }
+            }
+        } else {
+            for (; point < end_point; point++) {
+                if (!LineTo(canvas->dc, (int)fix_to_double(point->x),
+                            (int)fix_to_double(point->y))) {
+                    CANVAS_ERROR("LineTo failed");
+                }
+            }
+        }
+
+        if (flags & PATH_END) {
+
+            if (flags & PATH_CLOSE) {
+                if (!CloseFigure(canvas->dc)) {
+                    CANVAS_ERROR("CloseFigure failed");
+                }
+            }
+
+            if (!EndPath(canvas->dc)) {
+                CANVAS_ERROR("EndPath failed");
+            }
+        }
+
+    } while (more);
+}
+
+static void set_scale_mode(GdiCanvas *canvas, uint8_t scale_mode)
+{
+    if (scale_mode == IMAGE_SCALE_INTERPOLATE) {
+        SetStretchBltMode(canvas->dc, HALFTONE);
+    } else if (scale_mode == IMAGE_SCALE_NEAREST) {
+        SetStretchBltMode(canvas->dc, COLORONCOLOR);
+    } else {
+        CANVAS_ERROR("Unknown ScaleMode");
+    }
+}
+
+static void set_clip(GdiCanvas *canvas, Clip *clip)
+{
+    switch (clip->type) {
+    case CLIP_TYPE_NONE:
+        if (SelectClipRgn(canvas->dc, NULL) == ERROR) {
+            CANVAS_ERROR("SelectClipRgn failed");
+        }
+        break;
+    case CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+        access_test(&canvas->base, n, sizeof(uint32_t));
+
+        Rect *now = (Rect *)(n + 1);
+        Rect *end = now + *n;
+        access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+
+        if (now < end) {
+            HRGN main_hrgn;
+
+            main_hrgn = CreateRectRgn(now->left, now->top, now->right, now->bottom);
+            if (!main_hrgn) {
+                return;
+            }
+            now++;
+            for (; now < end; now++) {
+                HRGN combaine_hrgn;
+                combaine_hrgn = CreateRectRgn(now->left, now->top, now->right,
+                                              now->bottom);
+                if (!combaine_hrgn) {
+                    CANVAS_ERROR("Unable to CreateRectRgn");
+                    DeleteObject(main_hrgn);
+                    return;
+                }
+                if (CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR) == ERROR) {
+                    CANVAS_ERROR("Unable to CombineRgn");
+                    DeleteObject(combaine_hrgn);
+                    return;
+                }
+                DeleteObject(combaine_hrgn);
+            }
+            if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
+                CANVAS_ERROR("Unable to SelectClipRgn");
+            }
+            DeleteObject(main_hrgn);
+        }
+        break;
+    }
+    case CLIP_TYPE_PATH:
+        set_path(canvas, GET_ADDRESS(clip->data));
+        if (SelectClipPath(canvas->dc, RGN_COPY) == ERROR) {
+            CANVAS_ERROR("Unable to SelectClipPath");
+        }
+        break;
+    default:
+        CANVAS_ERROR("invalid clip type");
+    }
+}
+
+static void copy_bitmap(const uint8_t *src_image, int height, int src_stride,
+                        uint8_t *dest_bitmap, int dest_stride)
+{
+    int copy_width = MIN(dest_stride, src_stride);
+    int y = 0;
+
+    ASSERT(dest_stride >= 0 && src_stride >= 0);
+    while (y < height) {
+        memcpy(dest_bitmap, src_image, copy_width);
+        src_image += src_stride;
+        dest_bitmap += dest_stride;
+        y++;
+    }
+}
+
+static void copy_bitmap_alpha(const uint8_t *src_alpha, int height, int width, int src_stride,
+                              uint8_t *dest_bitmap, int dest_stride, int alpha_bits_size)
+{
+    int y = 0;
+    uint8_t i_offset;
+    int i_count = 0;
+    int i = 0;
+    int width_div_stride;
+
+    width_div_stride = width / src_stride;
+
+    if (alpha_bits_size == 1) {
+        i_offset = 1;
+    } else {
+        i_offset = 8;
+    }
+
+
+    while (y < height) {
+        int x;
+
+        for (x = 0; x < width; ++x) {
+            uint8_t alphaval;
+            double alpha;
+
+            alphaval = src_alpha[i];
+            alphaval = alphaval >> (i_count * i_offset);
+            alphaval = alphaval &= ((uint8_t)0xff >> (8 - i_offset));
+            alphaval = ((255 * alphaval) / ((uint8_t)0xff >> (8 - i_offset)));
+
+            dest_bitmap[x * 4 + 3] = alphaval;
+            alpha = (double)alphaval / 0xff;
+            dest_bitmap[x * 4 + 2] = (uint8_t)(alpha * dest_bitmap[x * 4 + 2]);
+            dest_bitmap[x * 4 + 1] = (uint8_t)(alpha * dest_bitmap[x * 4 + 1]);
+            dest_bitmap[x * 4] = (uint8_t)(alpha * dest_bitmap[x * 4]);
+
+            i_count++;
+            if (i_count == (8 / i_offset)) {
+                i++;
+                i_count = 0;
+            }
+        }
+
+        dest_bitmap += width * 4;
+        i = 0;
+        src_alpha += src_stride;
+        i_count = 0;
+        y++;
+    }
+}
+
+static uint8_t *create_bitmap(HBITMAP *bitmap, HBITMAP *prev_bitmap, HDC *dc,
+                              const uint8_t *bitmap_data, int width, int height,
+                              int stride, int bits, int rotate)
+{
+    uint8_t *data;
+    const uint8_t *src_data;
+    uint32_t nstride;
+    struct {
+        BITMAPINFO inf;
+        RGBQUAD palette[255];
+    } bitmap_info;
+
+    memset(&bitmap_info, 0, sizeof(bitmap_info));
+    bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+    bitmap_info.inf.bmiHeader.biWidth = width;
+    if (stride < 0) {
+        bitmap_info.inf.bmiHeader.biHeight = height;
+    } else {
+        bitmap_info.inf.bmiHeader.biHeight = -height;
+    }
+
+    if (rotate) {
+        bitmap_info.inf.bmiHeader.biHeight = -bitmap_info.inf.bmiHeader.biHeight;
+    }
+
+    bitmap_info.inf.bmiHeader.biPlanes = 1;
+    bitmap_info.inf.bmiHeader.biBitCount = bits;
+    bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+
+    *dc = create_compatible_dc();
+    if (!*dc) {
+        CANVAS_ERROR("create_compatible_dc() failed");
+        return NULL;
+    }
+
+    *bitmap = CreateDIBSection(*dc, &bitmap_info.inf, 0, (VOID **)&data, NULL, 0);
+    if (!*bitmap) {
+        CANVAS_ERROR("Unable to CreateDIBSection");
+        DeleteDC(*dc);
+        return NULL;
+    }
+    *prev_bitmap = (HBITMAP)SelectObject(*dc, *bitmap);
+
+    if (stride < 0) {
+        src_data = bitmap_data - (height - 1) * -stride;
+    } else {
+        src_data = bitmap_data;
+    }
+
+    switch (bits) {
+    case 1:
+        nstride = ALIGN(width, 32) / 8;
+        break;
+    case 8:
+        nstride = ALIGN(width, 4);
+        break;
+    case 32:
+        nstride = width * 4;
+        break;
+    default:
+        CANVAS_ERROR("invalid bitmap bits size");
+    }
+
+    if (bitmap_data) {
+        if (stride < 0) {
+            copy_bitmap(src_data, height, -stride, data, nstride);
+        } else {
+            copy_bitmap(src_data, height, stride, data, nstride);
+        }
+    }
+
+    return data;
+}
+
+static void release_bitmap(HDC dc, HBITMAP bitmap, HBITMAP prev_bitmap, int cache)
+{
+    bitmap = (HBITMAP)SelectObject(dc, prev_bitmap);
+    if (!cache) {
+        DeleteObject(bitmap);
+    }
+    DeleteDC(dc);
+}
+
+static inline uint8_t get_converted_color(uint8_t color)
+{
+    uint8_t msb;
+
+    msb = color & 0xE0;
+    msb = msb >> 5;
+    color |= msb;
+    return color;
+}
+
+static inline COLORREF get_color_ref(GdiCanvas *canvas, uint32_t color)
+{
+    int shift = canvas->base.color_shift == 8 ? 0 : 3;
+    uint8_t r, g, b;
+
+    b = (color & canvas->base.color_mask);
+    color >>= canvas->base.color_shift;
+    g = (color & canvas->base.color_mask);
+    color >>= canvas->base.color_shift;
+    r = (color & canvas->base.color_mask);
+    if (shift) {
+        r = get_converted_color(r << shift);
+        g = get_converted_color(g << shift);
+        b = get_converted_color(b << shift);
+    }
+    return RGB(r, g, b);
+}
+
+static HBRUSH get_brush(GdiCanvas *canvas, Brush *brush)
+{
+    HBRUSH hbrush;
+
+    switch (brush->type) {
+    case BRUSH_TYPE_SOLID:
+        if (!(hbrush = CreateSolidBrush(get_color_ref(canvas, brush->u.color)))) {
+            CANVAS_ERROR("CreateSolidBrush failed");
+        }
+        return hbrush;
+    case BRUSH_TYPE_PATTERN: {
+        GdiImage image;
+        HBRUSH hbrush;
+        cairo_surface_t *surface;
+        HDC dc;
+        HBITMAP bitmap;
+        HBITMAP prev_bitmap;
+
+        surface = canvas_get_image(&canvas->base, brush->u.pattern.pat);
+        surface_to_image(surface, &image);
+
+        if (!create_bitmap(&bitmap, &prev_bitmap, &dc, image.pixels, image.width,
+                           image.height, image.stride, 32, 0)) {
+            CANVAS_ERROR("create_bitmap failed");
+            return NULL;
+        }
+
+        if (!(hbrush = CreatePatternBrush(bitmap))) {
+            CANVAS_ERROR("CreatePatternBrush failed");
+        }
+
+        release_bitmap(dc, bitmap, prev_bitmap, 0);
+        cairo_surface_destroy(surface);
+        return hbrush;
+    }
+    case BRUSH_TYPE_NONE:
+        return NULL;
+    default:
+        CANVAS_ERROR("invalid brush type");
+        return NULL;
+    }
+}
+
+static HBRUSH set_brush(HDC dc, HBRUSH hbrush, Brush *brush)
+{
+    switch (brush->type) {
+    case BRUSH_TYPE_SOLID: {
+        return (HBRUSH)SelectObject(dc, hbrush);
+    }
+    case BRUSH_TYPE_PATTERN: {
+        HBRUSH prev_hbrush;
+        prev_hbrush = (HBRUSH)SelectObject(dc, hbrush);
+        if (!SetBrushOrgEx(dc, brush->u.pattern.pos.x, brush->u.pattern.pos.y, NULL)) {
+            CANVAS_ERROR("SetBrushOrgEx failed");
+        }
+        return prev_hbrush;
+    }
+    default:
+        CANVAS_ERROR("invalid brush type");
+        return NULL;
+    }
+}
+
+static void unset_brush(HDC dc, HBRUSH prev_hbrush)
+{
+    if (!prev_hbrush) {
+        return;
+    }
+    prev_hbrush = (HBRUSH)SelectObject(dc, prev_hbrush);
+    DeleteObject(prev_hbrush);
+}
+
+uint8_t calc_rop3(uint16_t rop3_bits, int brush)
+{
+    uint8_t rop3 = 0;
+    uint8_t rop3_src = _rop3_src;
+    uint8_t rop3_dest = _rop3_dest;
+    uint8_t rop3_brush = _rop3_brush;
+    uint8_t rop3_src_brush;
+
+    if (rop3_bits & ROPD_INVERS_SRC) {
+        rop3_src = ~rop3_src;
+    }
+    if (rop3_bits & ROPD_INVERS_BRUSH) {
+        rop3_brush = ~rop3_brush;
+    }
+    if (rop3_bits & ROPD_INVERS_DEST) {
+        rop3_dest = ~rop3_dest;
+    }
+
+    if (brush) {
+        rop3_src_brush = rop3_brush;
+    } else {
+        rop3_src_brush = rop3_src;
+    }
+
+    if (rop3_bits & ROPD_OP_PUT) {
+        rop3 = rop3_src_brush;
+    }
+    if (rop3_bits & ROPD_OP_OR) {
+        rop3 = rop3_src_brush | rop3_dest;
+    }
+    if (rop3_bits & ROPD_OP_AND) {
+        rop3 = rop3_src_brush & rop3_dest;
+    }
+    if (rop3_bits & ROPD_OP_XOR) {
+        rop3 = rop3_src_brush ^ rop3_dest;
+    }
+    if (rop3_bits & ROPD_INVERS_RES) {
+        rop3 = ~rop3_dest;
+    }
+
+    if (rop3_bits & ROPD_OP_BLACKNESS || rop3_bits & ROPD_OP_WHITENESS ||
+        rop3_bits & ROPD_OP_INVERS) {
+        CANVAS_ERROR("invalid rop3 type");
+    }
+    return rop3;
+}
+
+uint8_t calc_rop3_src_brush(uint16_t rop3_bits)
+{
+    uint8_t rop3 = 0;
+    uint8_t rop3_src = _rop3_src;
+    uint8_t rop3_brush = _rop3_brush;
+
+    if (rop3_bits & ROPD_INVERS_SRC) {
+        rop3_src = ~rop3_src;
+    }
+    if (rop3_bits & ROPD_INVERS_BRUSH) {
+        rop3_brush = ~rop3_brush;
+    }
+
+    if (rop3_bits & ROPD_OP_OR) {
+        rop3 = rop3_src | rop3_brush;
+    }
+    if (rop3_bits & ROPD_OP_AND) {
+        rop3 = rop3_src & rop3_brush;
+    }
+    if (rop3_bits & ROPD_OP_XOR) {
+        rop3 = rop3_src ^ rop3_brush;
+    }
+
+    return rop3;
+}
+
+static struct BitmapData get_mask_bitmap(struct GdiCanvas *canvas, struct QMask *mask)
+{
+    cairo_surface_t *surface;
+    struct BitmapData bitmap;
+    BitmapCache *bitmap_cache;
+
+    bitmap.hbitmap = NULL;
+    if (!(surface = canvas_get_mask(&canvas->base, mask))) {
+        return bitmap;
+    }
+
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        bitmap.dc = create_compatible_dc();
+        bitmap.prev_hbitmap = (HBITMAP)SelectObject(bitmap.dc, bitmap_cache->bitmap);
+        bitmap.hbitmap = bitmap_cache->bitmap;
+        ReleaseMutex(bitmap_cache->mutex);
+        bitmap.cache = 1;
+    } else if (!create_bitmap(&bitmap.hbitmap, &bitmap.prev_hbitmap, &bitmap.dc,
+                              cairo_image_surface_get_data(surface),
+                              cairo_image_surface_get_width(surface),
+                              cairo_image_surface_get_height(surface),
+                              cairo_image_surface_get_stride(surface), 1, 0)) {
+        bitmap.hbitmap = NULL;
+    } else {
+        bitmap.cache = 0;
+    }
+
+    bitmap.flags = mask->flags;
+    bitmap.pos = mask->pos;
+
+    return bitmap;
+}
+
+static void gdi_draw_bitmap(HDC dest_dc, const Rect *src, const Rect *dest,
+                            HDC src_dc, struct BitmapData *bitmapmask, uint32_t rop3_val)
+{
+    uint32_t rast_oper;
+
+    rast_oper = raster_ops[rop3_val];
+
+    if (!bitmapmask || !bitmapmask->hbitmap) {
+        if ((dest->right - dest->left) == (src->right - src->left) &&
+                                           (dest->bottom - dest->top) == (src->bottom - src->top)) {
+            if (!BitBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
+                        dest->bottom - dest->top, src_dc, src->left, src->top, rast_oper)) {
+                CANVAS_ERROR("BitBlt failed");
+            }
+        } else {
+            if (!StretchBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
+                            dest->bottom - dest->top, src_dc, src->left, src->top,
+                            src->right - src->left, src->bottom - src->top, rast_oper)) {
+                CANVAS_ERROR("StretchBlt failed");
+            }
+        }
+    } else {
+        rast_oper = MAKEROP4(rast_oper, raster_ops[_rop3_dest]);
+
+        if (!MaskBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
+                     dest->bottom - dest->top, src_dc, src->left, src->top,
+                     bitmapmask->hbitmap, bitmapmask->pos.x, bitmapmask->pos.y,
+                     rast_oper)) {
+            CANVAS_ERROR("MaskBlt failed");
+        }
+    }
+}
+
+static void gdi_draw_bitmap_redrop(HDC dest_dc, const Rect *src, const Rect *dest,
+                                   HDC src_dc, struct BitmapData *bitmapmask,
+                                   uint16_t rop, int brush)
+{
+    uint32_t rop3_val;
+
+    rop3_val = calc_rop3(rop, brush);
+    gdi_draw_bitmap(dest_dc, src, dest, src_dc, bitmapmask, rop3_val);
+}
+
+static void free_mask(struct BitmapData *bitmap)
+{
+    if (bitmap->hbitmap) {
+        release_bitmap(bitmap->dc, bitmap->hbitmap, bitmap->prev_hbitmap, bitmap->cache);
+    }
+}
+
+static void draw_str_mask_bitmap(struct GdiCanvas *canvas,
+                                 String *str, int n, Rect *dest,
+                                 Rect *src, Brush *brush)
+{
+    cairo_surface_t *surface;
+    struct BitmapData bitmap;
+    Point pos;
+    int dest_stride;
+    uint8_t *bitmap_data;
+    HBRUSH prev_hbrush;
+    HBRUSH hbrush;
+
+    bitmap.hbitmap = (HBITMAP)1;
+    if (!(surface = canvas_get_str_mask(&canvas->base, str, n, &pos))) {
+        CANVAS_ERROR("unable to canvas_get_str_mask");
+        return;
+    }
+
+    bitmap.cache = 0;
+    bitmap_data = create_bitmap(&bitmap.hbitmap, &bitmap.prev_hbitmap,
+                                &bitmap.dc, NULL,
+                                cairo_image_surface_get_width(surface),
+                                cairo_image_surface_get_height(surface),
+                                cairo_image_surface_get_stride(surface), 32, 0);
+
+    if (!bitmap_data) {
+        return;
+    }
+
+    bitmap.flags = 0;
+    bitmap.pos.x = 0;
+    bitmap.pos.y = 0;
+
+    dest->left = pos.x;
+    dest->top = pos.y;
+    dest->right = pos.x + cairo_image_surface_get_width(surface);
+    dest->bottom = pos.y + cairo_image_surface_get_height(surface);
+    src->left = 0;
+    src->top = 0;
+    src->right = cairo_image_surface_get_width(surface);
+    src->bottom = cairo_image_surface_get_height(surface);
+
+    dest_stride = cairo_image_surface_get_width(surface);
+    switch (n) {
+    case 1:
+        dest_stride = dest_stride / 8;
+        break;
+    case 4:
+        dest_stride = dest_stride / 2;
+        break;
+    case 32:
+        dest_stride = dest_stride * 4;
+        break;
+    default:
+        CANVAS_ERROR("unsupported bitmap bits size");
+    }
+    dest_stride = dest_stride + 3;
+    dest_stride = dest_stride & ~3;
+
+    hbrush = get_brush(canvas, brush);
+    prev_hbrush = set_brush(bitmap.dc, hbrush, brush);
+    gdi_draw_bitmap(bitmap.dc, src, src, bitmap.dc, NULL, _rop3_brush);
+
+    unset_brush(bitmap.dc, prev_hbrush);
+
+    copy_bitmap_alpha(cairo_image_surface_get_data(surface),
+                      cairo_image_surface_get_height(surface),
+                      cairo_image_surface_get_width(surface),
+                      cairo_image_surface_get_stride(surface),
+                      bitmap_data, dest_stride, n);
+
+    BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
+
+    Lock lock(*canvas->lock);
+    AlphaBlend(canvas->dc, dest->left, dest->top, dest->right - dest->left,
+               dest->bottom - dest->top, bitmap.dc, src->left, src->top,
+               src->right - src->left, src->bottom - src->top, bf);
+
+    free_mask(&bitmap);
+}
+
+static void gdi_draw_image(HDC dest_dc, const Rect *src, const Rect *dest,
+                           const uint8_t *bitmap_data, int bit_stride, int bit_width,
+                           int bit_height, struct BitmapData *bitmapmask, uint16_t rop,
+                           int rotate)
+{
+    HDC dc;
+    HBITMAP bitmap;
+    HBITMAP prev_bitmap;
+
+    create_bitmap(&bitmap, &prev_bitmap, &dc, bitmap_data, bit_width, bit_height,
+                  bit_stride, 32, rotate);
+
+    gdi_draw_bitmap_redrop(dest_dc, src, dest, dc, bitmapmask, rop, 0);
+
+    release_bitmap(dc, bitmap, prev_bitmap, 0);
+}
+
+static void gdi_draw_image_rop3(HDC dest_dc, const Rect *src, const Rect *dest,
+                                const uint8_t *bitmap_data, int bit_stride, int bit_width,
+                                int bit_height, struct BitmapData *bitmapmask, uint8_t rop3,
+                                int rotate)
+{
+    HDC dc;
+    HBITMAP bitmap;
+    HBITMAP prev_bitmap;
+
+    create_bitmap(&bitmap, &prev_bitmap, &dc, bitmap_data, bit_width, bit_height,
+                  bit_stride, 32, rotate);
+
+    gdi_draw_bitmap(dest_dc, src, dest, dc, bitmapmask, rop3);
+
+    release_bitmap(dc, bitmap, prev_bitmap, 0);
+}
+
+void gdi_canvas_draw_fill(GdiCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+{
+    HBRUSH prev_hbrush;
+    HBRUSH brush;
+    struct BitmapData bitmapmask;
+
+    if (!(brush = get_brush(canvas, &fill->brush))) {
+        CANVAS_ERROR("no braash");
+        return;
+    }
+    bitmapmask = get_mask_bitmap(canvas, &fill->mask);
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    prev_hbrush = set_brush(canvas->dc, brush, &fill->brush);
+    gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask,
+                           fill->rop_decriptor, fill->brush.type != BRUSH_TYPE_NONE);
+
+    free_mask(&bitmapmask);
+    unset_brush(canvas->dc, prev_hbrush);
+}
+
+void gdi_canvas_draw_copy(GdiCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    struct BitmapData bitmapmask;
+    BitmapCache *bitmap_cache;
+
+    bitmapmask = get_mask_bitmap(canvas, &copy->mask);
+    surface = canvas_get_image(&canvas->base, copy->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+
+    Lock lock(*canvas->lock);
+    set_scale_mode(canvas, copy->scale_mode);
+    set_clip(canvas, clip);
+
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap_redrop(canvas->dc, &copy->src_area, bbox, dc,
+                               &bitmapmask, copy->rop_decriptor, 0);
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image(canvas->dc, &copy->src_area, bbox, image.pixels,
+                       image.stride, image.width, image.height, &bitmapmask,
+                       copy->rop_decriptor, 0);
+    }
+
+    free_mask(&bitmapmask);
+
+    cairo_surface_destroy(surface);
+}
+
+void gdi_canvas_put_image(GdiCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+                          uint32_t src_width, uint32_t src_height, int src_stride,
+                          const QRegion *clip)
+{
+    Rect src;
+    src.top = 0;
+    src.bottom = src_height;
+    src.left = 0;
+    src.right = src_width;
+
+    Lock lock(*canvas->lock);
+    set_scale_mode(canvas, IMAGE_SCALE_NEAREST);
+    if (clip) {
+        if (clip->num_rects == 0) {
+            return;
+        } else {
+            HRGN main_hrgn;
+            uint32_t i;
+
+            main_hrgn = CreateRectRgn(clip->rects[0].left, clip->rects[0].top, clip->rects[0].right,
+                                      clip->rects[0].bottom);
+            if (!main_hrgn) {
+                return;
+            }
+
+            for (i = 1; i < clip->num_rects; i++) {
+                HRGN combaine_hrgn;
+
+                combaine_hrgn = CreateRectRgn(clip->rects[i].left, clip->rects[i].top,
+                                              clip->rects[i].right,
+                                              clip->rects[i].bottom);
+                if (!combaine_hrgn) {
+                    CANVAS_ERROR("CreateRectRgn failed");
+                    DeleteObject(main_hrgn);
+                    return;
+                }
+                if (!CombineRgn(main_hrgn, main_hrgn, combaine_hrgn, RGN_OR)) {
+                    CANVAS_ERROR("CombineRgn failed in put_image");
+                    return;
+                }
+                DeleteObject(combaine_hrgn);
+            }
+            if (SelectClipRgn(canvas->dc, main_hrgn) == ERROR) {
+                CANVAS_ERROR("SelectClipRgn failed in put_image");
+                DeleteObject(main_hrgn);
+                return;
+            }
+            DeleteObject(main_hrgn);
+        }
+    } else {
+        SelectClipRgn(canvas->dc, NULL);
+    }
+
+    if (dc) {
+        gdi_draw_bitmap_redrop(canvas->dc, &src, dest, dc,
+                               NULL, ROPD_OP_PUT, 0);
+    } else {
+        gdi_draw_image(canvas->dc, &src, dest, src_data,
+                       src_stride, src_width, src_height, NULL, ROPD_OP_PUT, 0);
+    }
+}
+
+static void gdi_draw_bitmap_transparent(GdiCanvas *canvas, HDC dest_dc, const Rect *src,
+                                        const Rect *dest, HDC src_dc, uint32_t color)
+{
+    TransparentBlt(dest_dc, dest->left, dest->top, dest->right - dest->left,
+                   dest->bottom - dest->top, src_dc, src->left, src->top,
+                   src->right - src->left, src->bottom - src->top,
+                   RGB(((uint8_t*)&color)[2], ((uint8_t*)&color)[1], ((uint8_t*)&color)[0]));
+}
+
+static void gdi_draw_image_transparent(GdiCanvas *canvas, HDC dest_dc, const Rect *src,
+                                       const Rect *dest, const uint8_t *bitmap_data,
+                                       int bit_stride, int bit_width, int bit_height,
+                                       uint32_t color, int rotate)
+{
+    HDC dc;
+    HBITMAP bitmap;
+    HBITMAP prev_bitmap;
+
+    create_bitmap(&bitmap, &prev_bitmap, &dc, bitmap_data, bit_width, bit_height,
+                  bit_stride, 32, rotate);
+
+    gdi_draw_bitmap_transparent(canvas, dest_dc, src, dest, dc, color);
+
+    release_bitmap(dc, bitmap, prev_bitmap, 0);
+}
+
+void gdi_canvas_draw_transparent(GdiCanvas *canvas, Rect *bbox, Clip *clip,
+                                 Transparent* transparent)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    BitmapCache *bitmap_cache;
+
+    surface = canvas_get_image(&canvas->base, transparent->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap_transparent(canvas, canvas->dc, &transparent->src_area, bbox, dc,
+                                    transparent->true_color);
+
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image_transparent(canvas, canvas->dc, &transparent->src_area, bbox, image.pixels,
+                                   image.stride, image.width, image.height,
+                                   transparent->true_color, 0);
+    }
+
+    cairo_surface_destroy(surface);
+}
+
+static void gdi_draw_bitmap_alpha(HDC dest_dc, const Rect *src, const Rect *dest,
+                                  HDC src_dc, uint8_t alpha)
+{
+    BLENDFUNCTION bf;
+
+    bf.BlendOp = AC_SRC_OVER;
+    bf.BlendFlags = 0;
+    bf.SourceConstantAlpha = alpha;
+    bf.AlphaFormat = AC_SRC_ALPHA;
+
+    if (!AlphaBlend(dest_dc, dest->left, dest->top, dest->right - dest->left,
+                    dest->bottom - dest->top, src_dc, src->left, src->top,
+                    src->right - src->left, src->bottom - src->top, bf)) {
+        CANVAS_ERROR("AlphaBlend failed");
+    }
+}
+
+static void gdi_draw_image_alpha(HDC dest_dc, const Rect *src, const Rect *dest,
+                                 const uint8_t *bitmap_data, int bit_stride,
+                                 int bit_width, int bit_height, uint8_t alpha,
+                                 int rotate)
+{
+    HDC dc;
+    HBITMAP bitmap;
+    HBITMAP prev_bitmap;
+
+    create_bitmap(&bitmap, &prev_bitmap, &dc, bitmap_data, bit_width, bit_height,
+                  bit_stride, 32, rotate);
+
+    gdi_draw_bitmap_alpha(dest_dc, src, dest, dc, alpha);
+
+    release_bitmap(dc, bitmap, prev_bitmap, 0);
+}
+
+void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    BitmapCache *bitmap_cache;
+
+    surface = canvas_get_image(&canvas->base, alpha_blend->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap_alpha(canvas->dc, &alpha_blend->src_area, bbox, dc, alpha_blend->alpha);
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image_alpha(canvas->dc, &alpha_blend->src_area, bbox, image.pixels,
+                             image.stride, image.width, image.height,
+                             alpha_blend->alpha, 0);
+    }
+
+    cairo_surface_destroy(surface);
+}
+
+void gdi_canvas_draw_opaque(GdiCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    struct BitmapData bitmapmask;
+    BitmapCache *bitmap_cache;
+    HBRUSH prev_hbrush;
+    HBRUSH hbrush;
+    uint8_t rop3;
+
+    surface = canvas_get_image(&canvas->base, opaque->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+    bitmapmask = get_mask_bitmap(canvas, &opaque->mask);
+    rop3 = calc_rop3_src_brush(opaque->rop_decriptor);
+    hbrush = get_brush(canvas, &opaque->brush);
+
+
+    Lock lock(*canvas->lock);
+    set_scale_mode(canvas, opaque->scale_mode);
+    set_clip(canvas, clip);
+    prev_hbrush = set_brush(canvas->dc, hbrush, &opaque->brush);
+
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap(canvas->dc, &opaque->src_area, bbox, dc, &bitmapmask, rop3);
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image_rop3(canvas->dc, &opaque->src_area, bbox, image.pixels,
+                            image.stride, image.width, image.height, &bitmapmask, rop3, 0);
+    }
+
+    unset_brush(canvas->dc, prev_hbrush);
+
+    free_mask(&bitmapmask);
+
+    cairo_surface_destroy(surface);
+}
+
+void gdi_canvas_draw_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    struct BitmapData bitmapmask;
+    BitmapCache *bitmap_cache;
+
+    bitmapmask = get_mask_bitmap(canvas, &blend->mask);
+    surface = canvas_get_image(&canvas->base, blend->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+
+    Lock lock(*canvas->lock);
+    set_scale_mode(canvas, blend->scale_mode);
+    set_clip(canvas, clip);
+
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap_redrop(canvas->dc, &blend->src_area, bbox, dc,
+                               &bitmapmask, blend->rop_decriptor, 0);
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image(canvas->dc, &blend->src_area, bbox, image.pixels, image.stride, image.width,
+                       image.height, &bitmapmask, blend->rop_decriptor, 0);
+    }
+
+    free_mask(&bitmapmask);
+
+    cairo_surface_destroy(surface);
+}
+
+void gdi_canvas_draw_blackness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    struct BitmapData bitmapmask;
+
+    bitmapmask = get_mask_bitmap(canvas, &blackness->mask);
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x0);
+
+    free_mask(&bitmapmask);
+}
+
+void gdi_canvas_draw_invers(GdiCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+{
+    struct BitmapData bitmapmask;
+
+    bitmapmask = get_mask_bitmap(canvas, &invers->mask);
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0x55);
+
+    free_mask(&bitmapmask);
+}
+
+void gdi_canvas_draw_whiteness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    struct BitmapData bitmapmask;
+
+    bitmapmask = get_mask_bitmap(canvas, &whiteness->mask);
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    gdi_draw_bitmap(canvas->dc, bbox, bbox, canvas->dc, &bitmapmask, 0xff);
+
+    free_mask(&bitmapmask);
+}
+
+void gdi_canvas_draw_rop3(GdiCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    cairo_surface_t *surface;
+    GdiImage image;
+    struct BitmapData bitmapmask;
+    HBRUSH prev_hbrush;
+    HBRUSH hbrush;
+    BitmapCache *bitmap_cache;
+
+    hbrush = get_brush(canvas, &rop3->brush);
+    surface = canvas_get_image(&canvas->base, rop3->src_bitmap);
+    bitmap_cache = (BitmapCache *)cairo_surface_get_user_data(surface, &bitmap_data_type);
+    bitmapmask = get_mask_bitmap(canvas, &rop3->mask);
+
+    Lock lock(*canvas->lock);
+    set_scale_mode(canvas, rop3->scale_mode);
+    set_clip(canvas, clip);
+    prev_hbrush = set_brush(canvas->dc, hbrush, &rop3->brush);
+
+    if (bitmap_cache && (WaitForSingleObject(bitmap_cache->mutex, INFINITE) != WAIT_FAILED)) {
+        HDC dc;
+        HBITMAP prev_bitmap;
+
+        dc = create_compatible_dc();
+        prev_bitmap = (HBITMAP)SelectObject(dc, bitmap_cache->bitmap);
+        gdi_draw_bitmap(canvas->dc, &rop3->src_area, bbox, dc,
+                        &bitmapmask, rop3->rop3);
+        SelectObject(dc, prev_bitmap);
+        DeleteObject(dc);
+        ReleaseMutex(bitmap_cache->mutex);
+    } else {
+        surface_to_image(surface, &image);
+        gdi_draw_image_rop3(canvas->dc, &rop3->src_area, bbox, image.pixels,
+                            image.stride, image.width, image.height, &bitmapmask, rop3->rop3, 0);
+    }
+
+    unset_brush(canvas->dc, prev_hbrush);
+    free_mask(&bitmapmask);
+
+    cairo_surface_destroy(surface);
+}
+
+void gdi_canvas_copy_bits(GdiCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+{
+    Lock lock(*canvas->lock);
+
+    set_clip(canvas, clip);
+
+    BitBlt(canvas->dc, bbox->left, bbox->top, bbox->right - bbox->left,
+           bbox->bottom - bbox->top, canvas->dc, src_pos->x, src_pos->y, SRCCOPY);
+}
+
+void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+{
+    String *str;
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+    lock.unlock();
+
+    if (!rect_is_empty(&text->back_area)) {
+        HBRUSH prev_hbrush;
+        HBRUSH hbrush;
+
+        hbrush = get_brush(canvas, &text->back_brush);
+        Lock lock(*canvas->lock);
+        prev_hbrush = set_brush(canvas->dc, hbrush, &text->back_brush);
+        gdi_draw_bitmap_redrop(canvas->dc, bbox, bbox, canvas->dc, NULL,
+                               text->back_mode, 1);
+        unset_brush(canvas->dc, prev_hbrush);
+    }
+
+    str = (String *)GET_ADDRESS(text->str);
+
+    if (str->flags & STRING_RASTER_A1) {
+        Rect dest;
+        Rect src;
+
+        draw_str_mask_bitmap(canvas, str, 1, &dest, &src, &text->fore_brush);
+    } else if (str->flags & STRING_RASTER_A4) {
+        Rect dest;
+        Rect src;
+
+        draw_str_mask_bitmap(canvas, str, 4, &dest, &src, &text->fore_brush);
+    } else if (str->flags & STRING_RASTER_A8) {
+        WARN("untested path A8 glyphs, doing nothing");
+        if (0) {
+            Rect dest;
+            Rect src;
+
+            draw_str_mask_bitmap(canvas, str, 8, &dest, &src, &text->fore_brush);
+        }
+    } else {
+        WARN("untested path vector glyphs, doing nothing");
+        if (0) {
+        }
+    }
+}
+
+static int get_join_style(uint8_t join_style)
+{
+    switch (join_style) {
+    case LINE_JOIN_ROUND:
+        return PS_JOIN_ROUND;
+    case LINE_JOIN_BEVEL:
+        return PS_JOIN_BEVEL;
+    case LINE_JOIN_MITER:
+        return PS_JOIN_MITER;
+    default:
+        CANVAS_ERROR("bad join style %d", join_style);
+    }
+}
+
+static int get_cap(int end_style)
+{
+    switch (end_style) {
+    case LINE_CAP_ROUND:
+        return PS_ENDCAP_ROUND;
+    case LINE_CAP_SQUARE:
+        return PS_ENDCAP_SQUARE;
+    case LINE_CAP_BUTT:
+        return PS_ENDCAP_FLAT;
+    default:
+        CANVAS_ERROR("bad end style %d", end_style);
+    }
+}
+
+static uint32_t *gdi_get_userstyle(GdiCanvas *canvas, UINT8 nseg, ADDRESS addr, int start_is_gap)
+{
+    FIXED28_4* style = (FIXED28_4*)GET_ADDRESS(addr);
+    double offset = 0;
+    uint32_t *local_style;
+    int i;
+
+    access_test(&canvas->base, style, nseg * sizeof(*style));
+
+    if (nseg == 0) {
+        CANVAS_ERROR("bad nseg");
+    }
+    local_style = (uint32_t *)malloc(nseg * sizeof(*local_style));
+
+    if (start_is_gap) {
+        offset = (uint32_t)fix_to_double(*style);
+        local_style[nseg - 1] = (uint32_t)fix_to_double(*style);
+        style++;
+
+        for (i = 0; i < nseg - 1; i++, style++) {
+            local_style[i] = (uint32_t)fix_to_double(*style);
+        }
+    } else {
+        for (i = 0; i < nseg; i++, style++) {
+            local_style[i] = (uint32_t)fix_to_double(*style);
+        }
+    }
+
+    return local_style;
+}
+
+void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    HPEN hpen;
+    HPEN prev_hpen;
+    LOGBRUSH logbrush;
+    int ps_join = 0;
+    int line_cap = 0;
+    uint32_t *user_style = NULL;
+    cairo_surface_t *surface = NULL;
+
+    if (stroke->brush.type == BRUSH_TYPE_PATTERN) {
+        surface = canvas_get_image(&canvas->base, stroke->brush.u.pattern.pat);
+    }
+
+    Lock lock(*canvas->lock);
+    set_clip(canvas, clip);
+
+    switch (stroke->fore_mode) {
+    case ROPD_OP_WHITENESS:
+        SetROP2(canvas->dc, R2_WHITE);    //0
+        break;
+    case ROPD_OP_BLACKNESS:
+        SetROP2(canvas->dc, R2_BLACK);    //1
+        break;
+    case ROPD_OP_INVERS:
+        SetROP2(canvas->dc, R2_NOT);    //Dn
+        break;
+    case ROPD_OP_PUT:
+        SetROP2(canvas->dc, R2_COPYPEN);    //P
+        break;
+    case ROPD_OP_OR:
+        SetROP2(canvas->dc, R2_MERGEPEN);    //DPo
+        break;
+    case ROPD_OP_XOR:
+        SetROP2(canvas->dc, R2_XORPEN);    //DPx
+        break;
+    case ROPD_OP_AND:
+        SetROP2(canvas->dc, R2_MASKPEN);    //DPa
+        break;
+    case ROPD_INVERS_BRUSH | ROPD_OP_PUT:    //Pn
+        SetROP2(canvas->dc, R2_NOTCOPYPEN);
+        break;
+    case ROPD_OP_XOR | ROPD_INVERS_RES:
+        SetROP2(canvas->dc, R2_NOTXORPEN);    //DPxn
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_RES:
+        SetROP2(canvas->dc, R2_NOTMERGEPEN);    //DPon
+        break;
+    case ROPD_OP_AND | ROPD_INVERS_RES:
+        SetROP2(canvas->dc, R2_NOTMASKPEN);    //DPan
+        break;
+    case ROPD_INVERS_DEST | ROPD_OP_AND:
+        SetROP2(canvas->dc, R2_MASKPENNOT);    //PDna
+        break;
+    case ROPD_INVERS_BRUSH | ROPD_OP_AND:
+        SetROP2(canvas->dc, R2_MASKNOTPEN);    //DPna
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_BRUSH:
+        SetROP2(canvas->dc, R2_MERGENOTPEN);    //DPno
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_DEST:
+        SetROP2(canvas->dc, R2_MERGEPENNOT);    //PDno
+        break;
+    default:
+        SetROP2(canvas->dc, R2_NOP);    //D
+    }
+
+
+    if (stroke->brush.type == BRUSH_TYPE_SOLID) {
+        logbrush.lbStyle = BS_SOLID | DIB_RGB_COLORS;
+        logbrush.lbHatch = 0;
+        logbrush.lbColor = get_color_ref(canvas, stroke->brush.u.color);
+    } else if (stroke->brush.type == BRUSH_TYPE_PATTERN) {
+#if 0
+        struct {
+            BITMAPINFO inf;
+            RGBQUAD palette[255];
+        } bitmap_info;
+        GdiImage image;
+#endif
+        //CANVAS_ERROR("untested path stroke brush with pattern");
+#if 0
+        ASSERT(surface)
+        surface_to_image(surface, &image);
+
+        memset(&bitmap_info, 0, sizeof(bitmap_info));
+        bitmap_info.inf.bmiHeader.biSize = sizeof(bitmap_info.inf.bmiHeader);
+        bitmap_info.inf.bmiHeader.biWidth = image.width;
+        if (image.stride < 0) {
+            bitmap_info.inf.bmiHeader.biHeight = image.height;
+        } else {
+            bitmap_info.inf.bmiHeader.biHeight = -image.height;
+        }
+        bitmap_info.inf.bmiHeader.biPlanes = 1;
+        bitmap_info.inf.bmiHeader.biBitCount = 32;
+        bitmap_info.inf.bmiHeader.biCompression = BI_RGB;
+
+        if (image.stride < 0) {
+            logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
+                                                 image.height * -image.stride + sizeof(BITMAPINFO));
+            if (!logbrush.lbHatch) {
+                CANVAS_ERROR("GlobalAlloc failed");
+            }
+            copy_bitmap(image.pixels - (image.height - 1) * -image.stride,
+                        image.height, -image.stride,
+                        (uint8_t *)logbrush.lbHatch, image.width);
+        } else {
+            logbrush.lbHatch = (LONG)GlobalAlloc(GMEM_MOVEABLE,
+                                                 image.height * image.stride + sizeof(BITMAPINFO));
+            if (!logbrush.lbHatch) {
+                CANVAS_ERROR("GlobalAlloc failed");
+            }
+            copy_bitmap(image.pixels, image.height, image.stride,
+                        (uint8_t *)logbrush.lbHatch, image.width);
+        }
+
+        memcpy((void *)logbrush.lbHatch, &bitmap_info.inf, sizeof(BITMAPINFO));
+
+        logbrush.lbStyle = BS_DIBPATTERN | DIB_RGB_COLORS;
+        logbrush.lbColor = 0;
+#endif
+        cairo_surface_destroy(surface);
+    }
+
+#if 0
+    ps_join = get_join_style(stroke->attr.join_style);
+    line_cap = get_cap(stroke->attr.end_style);
+
+    SetMiterLimit(canvas->dc, (FLOAT)fix_to_double(stroke->attr.miter_limit), &old_miter);
+#endif
+
+    if (stroke->attr.flags & LINE_ATTR_STYLED) {
+        user_style = gdi_get_userstyle(canvas, stroke->attr.style_nseg,
+                                       stroke->attr.style,
+                                       !!(stroke->attr.flags & LINE_ATTR_STARTGAP));
+        hpen = ExtCreatePen(PS_GEOMETRIC | ps_join | line_cap | PS_USERSTYLE,
+                            (uint32_t)fix_to_double(stroke->attr.width),
+                            &logbrush, stroke->attr.style_nseg, (DWORD *)user_style);
+    } else {
+        hpen = ExtCreatePen(PS_GEOMETRIC | ps_join | line_cap,
+                            (uint32_t)fix_to_double(stroke->attr.width),
+                            &logbrush, 0, NULL);
+    }
+    prev_hpen = (HPEN)SelectObject(canvas->dc, hpen);
+
+    set_path(canvas, GET_ADDRESS(stroke->path));
+
+    StrokePath(canvas->dc);
+
+    SelectObject(canvas->dc, prev_hpen);
+    DeleteObject(hpen);
+
+#if 0
+    if (stroke->brush.type == BRUSH_TYPE_PATTERN) {
+        GlobalFree((HGLOBAL)logbrush.lbHatch);
+    }
+#endif
+
+    if (user_style) {
+        free(user_style);
+    }
+}
+
+void gdi_canvas_clear(GdiCanvas *canvas)
+{
+}
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void gdi_canvas_set_access_params(GdiCanvas *canvas, ADDRESS delta, unsigned long base,
+                                  unsigned long max)
+{
+    __canvas_set_access_params(&canvas->base, delta, base, max);
+}
+
+#else
+void gdi_canvas_set_access_params(GdiCanvas *canvas, ADDRESS delta)
+{
+    __gdi_canvas_set_access_params(&canvas->base, delta);
+}
+
+#endif
+
+void gdi_canvas_destroy(GdiCanvas *canvas)
+{
+    if (!canvas) {
+        return;
+    }
+    canvas_base_destroy(&canvas->base);
+    free(canvas);
+}
+
+static int need_init = 1;
+
+#ifdef CAIRO_CANVAS_CACHE
+GdiCanvas *gdi_canvas_create(HDC dc, Mutex* lock, int bits, void *bits_cache_opaque,
+                             bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get,
+                             void *palette_cache_opaque, palette_cache_put_fn_t palette_cache_put,
+                             palette_cache_get_fn_t palette_cache_get,
+                             palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+GdiCanvas *gdi_canvas_create(HDC dc, int bits,
+                             void *bits_cache_opaque,
+                             bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get
+#else
+GdiCanvas *gdi_canvas_create(HDC dc, int bits
+#endif
+#ifdef USE_GLZ
+                            , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                            )
+{
+    GdiCanvas *canvas;
+    int init_ok;
+
+    if (need_init || !(canvas = (GdiCanvas *)malloc(sizeof(GdiCanvas)))) {
+        return NULL;
+    }
+    memset(canvas, 0, sizeof(GdiCanvas));
+#ifdef CAIRO_CANVAS_CACHE
+    init_ok = canvas_base_init(&canvas->base, bits,
+                               bits_cache_opaque,
+                               bits_cache_put,
+                               bits_cache_get,
+                               palette_cache_opaque,
+                               palette_cache_put,
+                               palette_cache_get,
+                               palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+    init_ok = gdi_canvas_base_init(&canvas->base, bits,
+                                   bits_cache_opaque,
+                                   bits_cache_put,
+                                   bits_cache_get
+#else
+    init_ok = gdi_canvas_base_init(&canvas->base, bits
+#endif
+#ifdef USE_GLZ
+                               ,
+                               glz_decoder_opaque,
+                               glz_decode
+#endif
+                               );
+    canvas->dc = dc;
+    canvas->lock = lock;
+    return canvas;
+}
+
+void gdi_canvas_init() //unsafe global function
+{
+    if (!need_init) {
+        return;
+    }
+    need_init = 0;
+    rop3_init();
+}
+
diff --git a/common/gdi_canvas.h b/common/gdi_canvas.h
new file mode 100644
index 00000000..13d7ef3d
--- /dev/null
+++ b/common/gdi_canvas.h
@@ -0,0 +1,76 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H__GDI_CANVAS
+#define _H__GDI_CANVAS
+
+#include <stdint.h>
+
+#include "draw.h"
+#include "cairo.h"
+#include "canvas_base.h"
+#include "region.h"
+
+typedef struct GdiCanvas GdiCanvas;
+
+typedef struct {
+    int width;
+    int height;
+    int stride;
+    uint8_t *pixels;
+} GdiImage;
+
+void gdi_canvas_draw_fill(GdiCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
+void gdi_canvas_draw_copy(GdiCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
+void gdi_canvas_draw_opaque(GdiCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
+void gdi_canvas_copy_bits(GdiCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
+void gdi_canvas_draw_text(GdiCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
+void gdi_canvas_draw_stroke(GdiCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
+void gdi_canvas_draw_rop3(GdiCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
+void gdi_canvas_draw_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
+void gdi_canvas_draw_blackness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
+void gdi_canvas_draw_whiteness(GdiCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
+void gdi_canvas_draw_invers(GdiCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
+void gdi_canvas_draw_transparent(GdiCanvas *canvas, Rect *bbox, Clip *clip,
+                                 Transparent* transparent);
+void gdi_canvas_draw_alpha_blend(GdiCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+void gdi_canvas_put_image(GdiCanvas *canvas, HDC dc, const Rect *dest, const uint8_t *src_data,
+                          uint32_t src_width, uint32_t src_height, int src_stride,
+                          const QRegion *clip);
+void gdi_canvas_clear(GdiCanvas *canvas);
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void gdi_canvas_set_access_params(GdiCanvas *canvas, ADDRESS delta, unsigned long base,
+                                  unsigned long max);
+#else
+void gdi_canvas_set_access_params(GdiCanvas *canvas, ADDRESS delta);
+#endif
+
+
+GdiCanvas *gdi_canvas_create(HDC dc, class Mutex *lock, int bits, void *bits_cache_opaque,
+                             bits_cache_put_fn_t bits_cache_put, bits_cache_get_fn_t bits_cache_get,
+                             void *palette_cache_opaque, palette_cache_put_fn_t palette_cache_put,
+                             palette_cache_get_fn_t palette_cache_get,
+                             palette_cache_release_fn_t palette_cache_release,
+                             void *glz_decoder_opaque,
+                             glz_decode_fn_t glz_decode);
+
+void gdi_canvas_destroy(GdiCanvas *canvas);
+
+void gdi_canvas_init();
+
+#endif
diff --git a/common/gl_canvas.c b/common/gl_canvas.c
new file mode 100644
index 00000000..aac93c92
--- /dev/null
+++ b/common/gl_canvas.c
@@ -0,0 +1,886 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gl_canvas.h"
+#include "quic.h"
+#include "rop3.h"
+#include "region.h"
+
+#define GL_CANVAS
+#include "canvas_base.c"
+
+struct GLCanvas {
+    CanvasBase base;
+    GLCCtx glc;
+    void *usr_data;
+    void *private_data;
+    int private_data_size;
+};
+
+static inline uint8_t *copy_opposite_image(GLCanvas *canvas, void *data, int stride, int height)
+{
+    uint8_t *ret_data = (uint8_t *)data;
+    uint8_t *dest;
+    uint8_t *src;
+    int i;
+
+    if (!canvas->private_data) {
+        canvas->private_data = malloc(stride * height);
+        if (!canvas->private_data) {
+            return ret_data;
+        }
+        canvas->private_data_size = stride * height;
+    }
+
+    if (canvas->private_data_size < (stride * height)) {
+        free(canvas->private_data);
+        canvas->private_data = malloc(stride * height);
+        if (!canvas->private_data) {
+            return ret_data;
+        }
+        canvas->private_data_size = stride * height;
+    }
+
+    dest = (uint8_t *)canvas->private_data;
+    src = (uint8_t *)data + (height - 1) * stride;
+
+    for (i = 0; i < height; ++i) {
+        memcpy(dest, src, stride);
+        dest += stride;
+        src -= stride;
+    }
+    return (uint8_t *)canvas->private_data;
+}
+
+static cairo_surface_t *canvas_surf_to_trans_surf(GLCImage *image,
+                                                  uint32_t trans_color)
+{
+    int width = image->width;
+    int height = image->height;
+    uint8_t *src_line;
+    uint8_t *end_src_line;
+    int src_stride;
+    uint8_t *dest_line;
+    int dest_stride;
+    cairo_surface_t *ret;
+    int i;
+
+    ret = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+    if (cairo_surface_status(ret) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(ret)));
+    }
+
+    src_line = image->pixels;
+    src_stride = image->stride;
+    end_src_line = src_line + src_stride * height;
+
+    dest_line = cairo_image_surface_get_data(ret);
+    dest_stride = cairo_image_surface_get_stride(ret);
+
+    for (; src_line < end_src_line; src_line += src_stride, dest_line += dest_stride) {
+        for (i = 0; i < width; i++) {
+            if ((((uint32_t*)src_line)[i] & 0x00ffffff) == trans_color) {
+                ((uint32_t*)dest_line)[i] = 0;
+            } else {
+                ((uint32_t*)dest_line)[i] = (((uint32_t*)src_line)[i]) | 0xff000000;
+            }
+        }
+    }
+
+    return ret;
+}
+
+static GLCPath get_path(GLCanvas *canvas, void *addr)
+{
+    GLCPath path = glc_path_create(canvas->glc);
+    uint32_t* data_size = (uint32_t*)addr;
+    access_test(&canvas->base, data_size, sizeof(uint32_t));
+    uint32_t more = *data_size;
+
+    PathSeg* seg = (PathSeg*)(data_size + 1);
+
+    do {
+        access_test(&canvas->base, seg, sizeof(PathSeg));
+
+        uint32_t flags = seg->flags;
+        PointFix* point = (PointFix*)seg->data;
+        PointFix* end_point = point + seg->count;
+        access_test(&canvas->base, point, (unsigned long)end_point - (unsigned long)point);
+        ASSERT(point < end_point);
+        more -= ((unsigned long)end_point - (unsigned long)seg);
+        seg = (PathSeg*)end_point;
+
+        if (flags & PATH_BEGIN) {
+            glc_path_move_to(path, fix_to_double(point->x), fix_to_double(point->y));
+            point++;
+        }
+
+        if (flags & PATH_BEZIER) {
+            ASSERT((point - end_point) % 3 == 0);
+            for (; point + 2 < end_point; point += 3) {
+                glc_path_curve_to(path,
+                                  fix_to_double(point[0].x), fix_to_double(point[0].y),
+                                  fix_to_double(point[1].x), fix_to_double(point[1].y),
+                                  fix_to_double(point[2].x), fix_to_double(point[2].y));
+            }
+        } else {
+            for (; point < end_point; point++) {
+                glc_path_line_to(path, fix_to_double(point->x), fix_to_double(point->y));
+            }
+        }
+        if (flags & PATH_END) {
+            if (flags & PATH_CLOSE) {
+                glc_path_close(path);
+            }
+        }
+    } while (more);
+
+    return path;
+}
+
+#define SET_GLC_RECT(dest, src) {                   \
+    (dest)->x = (src)->left;                        \
+    (dest)->y = (src)->top;                         \
+    (dest)->width = (src)->right - (src)->left;     \
+    (dest)->height = (src)->bottom - (src)->top;    \
+}
+
+static void set_clip(GLCanvas *canvas, Rect *bbox, Clip *clip)
+{
+    GLCRect rect;
+    glc_clip_reset(canvas->glc);
+
+    switch (clip->type) {
+    case CLIP_TYPE_NONE:
+        break;
+    case CLIP_TYPE_RECTS: {
+        uint32_t *n = (uint32_t *)GET_ADDRESS(clip->data);
+        access_test(&canvas->base, n, sizeof(uint32_t));
+        Rect *now = (Rect *)(n + 1);
+        Rect *end = now + *n;
+        access_test(&canvas->base, now, (unsigned long)end - (unsigned long)now);
+
+        if (*n == 0) {
+            rect.x = rect.y = 0;
+            rect.width = rect.height = 0;
+            glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
+            break;
+        } else {
+            SET_GLC_RECT(&rect, now);
+            glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
+        }
+
+        for (now++; now < end; now++) {
+            SET_GLC_RECT(&rect, now);
+            glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_OR);
+        }
+        break;
+    }
+    case CLIP_TYPE_PATH: {
+        GLCPath path = get_path(canvas, GET_ADDRESS(clip->data));
+        glc_clip_path(canvas->glc, path, GLC_CLIP_OP_SET);
+        glc_path_destroy(path);
+        break;
+    }
+    default:
+        CANVAS_ERROR("invalid clip type");
+    }
+}
+
+static void set_mask(GLCanvas *canvas, QMask *mask, int x, int y)
+{
+    cairo_surface_t *surface;
+
+    if (!(surface = canvas_get_mask(&canvas->base, mask))) {
+        glc_clear_mask(canvas->glc, GLC_MASK_A);
+        return;
+    }
+
+
+    glc_set_mask(canvas->glc, x - mask->pos.x, y - mask->pos.y,
+                 cairo_image_surface_get_width(surface),
+                 cairo_image_surface_get_height(surface),
+                 cairo_image_surface_get_stride(surface),
+                 cairo_image_surface_get_data(surface), GLC_MASK_A);
+}
+
+static inline void surface_to_image(GLCanvas *canvas, cairo_surface_t *surface, GLCImage *image,
+                                    int ignore_stride)
+{
+    cairo_format_t format = cairo_image_surface_get_format(surface);
+
+    ASSERT(format == CAIRO_FORMAT_ARGB32 || format == CAIRO_FORMAT_RGB24);
+    image->format = (format == CAIRO_FORMAT_RGB24) ? GLC_IMAGE_RGB32 : GLC_IMAGE_ARGB32;
+    image->width = cairo_image_surface_get_width(surface);
+    image->height = cairo_image_surface_get_height(surface);
+    image->stride = cairo_image_surface_get_stride(surface);
+    image->pixels = cairo_image_surface_get_data(surface);
+    image->pallet = NULL;
+    if (ignore_stride) {
+        return;
+    }
+    if (image->stride < 0) {
+        image->stride = -image->stride;
+        image->pixels = image->pixels - (image->height - 1) * image->stride;
+    } else {
+        image->pixels = copy_opposite_image(canvas, image->pixels, image->stride, image->height);
+    }
+}
+
+static void set_brush(GLCanvas *canvas, Brush *brush)
+{
+    switch (brush->type) {
+    case BRUSH_TYPE_SOLID: {
+        uint32_t color = brush->u.color;
+        double r, g, b;
+
+        b = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        color >>= canvas->base.color_shift;
+        g = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        color >>= canvas->base.color_shift;
+        r = (double)(color & canvas->base.color_mask) / canvas->base.color_mask;
+        glc_set_rgb(canvas->glc, r, g, b);
+        break;
+    }
+    case BRUSH_TYPE_PATTERN: {
+        GLCImage image;
+        GLCPattern pattern;
+        cairo_surface_t *surface;
+
+        surface = canvas_get_image(&canvas->base, brush->u.pattern.pat);
+        surface_to_image(canvas, surface, &image, 0);
+
+        pattern = glc_pattern_create(canvas->glc, -brush->u.pattern.pos.x,
+                                     -brush->u.pattern.pos.y, &image);
+
+        glc_set_pattern(canvas->glc, pattern);
+        glc_pattern_destroy(pattern);
+    }
+    case BRUSH_TYPE_NONE:
+        return;
+    default:
+        CANVAS_ERROR("invalid brush type");
+    }
+}
+
+static void set_op(GLCanvas *canvas, UINT16 rop_decriptor)
+{
+    GLCOp op;
+
+    switch (rop_decriptor) {
+    case ROPD_OP_PUT:
+        op = GLC_OP_COPY;
+        break;
+    case ROPD_OP_XOR:
+        op = GLC_OP_XOR;
+        break;
+    case ROPD_OP_BLACKNESS:
+        op = GLC_OP_CLEAR;
+        break;
+    case ROPD_OP_WHITENESS:
+        op = GLC_OP_SET;
+        break;
+    case ROPD_OP_PUT | ROPD_INVERS_BRUSH:
+    case ROPD_OP_PUT | ROPD_INVERS_SRC:
+        op = GLC_OP_COPY_INVERTED;
+        break;
+    case ROPD_OP_INVERS:
+        op = GLC_OP_INVERT;
+        break;
+    case ROPD_OP_AND:
+        op = GLC_OP_AND;
+        break;
+    case ROPD_OP_AND | ROPD_INVERS_RES:
+        op = GLC_OP_NAND;
+        break;
+    case ROPD_OP_OR:
+        op = GLC_OP_OR;
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_RES:
+        op = GLC_OP_NOR;
+        break;
+    case ROPD_OP_XOR | ROPD_INVERS_RES:
+        op = GLC_OP_EQUIV;
+        break;
+    case ROPD_OP_AND | ROPD_INVERS_DEST:
+        op = GLC_OP_AND_REVERSE;
+        break;
+    case ROPD_OP_AND | ROPD_INVERS_BRUSH:
+    case ROPD_OP_AND | ROPD_INVERS_SRC:
+        op = GLC_OP_AND_INVERTED;
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_DEST:
+        op = GLC_OP_OR_REVERSE;
+        break;
+    case ROPD_OP_OR | ROPD_INVERS_BRUSH:
+    case ROPD_OP_OR | ROPD_INVERS_SRC:
+        op = GLC_OP_OR_INVERTED;
+        break;
+    default:
+        WARN("GLC_OP_NOOP");
+        op = GLC_OP_NOOP;
+    }
+    glc_set_op(canvas->glc, op);
+}
+
+void gl_canvas_draw_fill(GLCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill)
+{
+    GLCRect rect;
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, &fill->mask, bbox->left, bbox->top);
+    set_brush(canvas, &fill->brush);
+    set_op(canvas, fill->rop_decriptor);
+    SET_GLC_RECT(&rect, bbox);
+
+    glc_fill_rect(canvas->glc, &rect);
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_draw_copy(GLCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy)
+{
+    cairo_surface_t *surface;
+    GLCRecti src;
+    GLCRecti dest;
+    GLCImage image;
+
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, &copy->mask, bbox->left, bbox->top);
+    set_op(canvas, copy->rop_decriptor);
+
+    //todo: optimize get_imag (use ogl conversion + remove unnecessary copy of 32bpp)
+    surface = canvas_get_image(&canvas->base, copy->src_bitmap);
+    surface_to_image(canvas, surface, &image, 0);
+    SET_GLC_RECT(&dest, bbox);
+    SET_GLC_RECT(&src, &copy->src_area);
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
+
+    cairo_surface_destroy(surface);
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque)
+{
+    cairo_surface_t *surface;
+    GLCRecti src;
+    GLCRecti dest;
+    GLCRect fill_rect;
+    GLCImage image;
+
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, &opaque->mask, bbox->left, bbox->top);
+
+    glc_set_op(canvas->glc, (opaque->rop_decriptor & ROPD_INVERS_SRC) ? GLC_OP_COPY_INVERTED :
+               GLC_OP_COPY);
+    surface = canvas_get_image(&canvas->base, opaque->src_bitmap);
+    surface_to_image(canvas, surface, &image, 0);
+    SET_GLC_RECT(&dest, bbox);
+    SET_GLC_RECT(&src, &opaque->src_area);
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
+    cairo_surface_destroy(surface);
+
+    set_brush(canvas, &opaque->brush);
+    set_op(canvas, opaque->rop_decriptor & ~ROPD_INVERS_SRC);
+    SET_GLC_RECT(&fill_rect, bbox);
+    glc_fill_rect(canvas->glc, &fill_rect);
+
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_draw_alpha_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd *alpha_blend)
+{
+    cairo_surface_t *surface;
+    GLCRecti src;
+    GLCRecti dest;
+    GLCImage image;
+
+    set_clip(canvas, bbox, clip);
+    glc_clear_mask(canvas->glc, GLC_MASK_A);
+    glc_set_op(canvas->glc, GLC_OP_COPY);
+
+    surface = canvas_get_image(&canvas->base, alpha_blend->src_bitmap);
+    surface_to_image(canvas, surface, &image, 0);
+    SET_GLC_RECT(&dest, bbox);
+    SET_GLC_RECT(&src, &alpha_blend->src_area);
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, (double)alpha_blend->alpha / 0xff);
+
+    cairo_surface_destroy(surface);
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_draw_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend)
+{
+    cairo_surface_t *surface;
+    GLCRecti src;
+    GLCRecti dest;
+    GLCImage image;
+
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, &blend->mask, bbox->left, bbox->top);
+    set_op(canvas, blend->rop_decriptor);
+
+    surface = canvas_get_image(&canvas->base, blend->src_bitmap);
+    SET_GLC_RECT(&dest, bbox);
+    SET_GLC_RECT(&src, &blend->src_area);
+    surface_to_image(canvas, surface, &image, 0);
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
+
+    cairo_surface_destroy(surface);
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_draw_transparent(GLCanvas *canvas, Rect *bbox, Clip *clip, Transparent *transparent)
+{
+    cairo_surface_t *surface;
+    cairo_surface_t *trans_surf;
+    GLCImage image;
+    GLCRecti src;
+    GLCRecti dest;
+
+    set_clip(canvas, bbox, clip);
+    glc_clear_mask(canvas->glc, GLC_MASK_A);
+    glc_set_op(canvas->glc, GLC_OP_COPY);
+
+    surface = canvas_get_image(&canvas->base, transparent->src_bitmap);
+    surface_to_image(canvas, surface, &image, 0);
+
+    trans_surf = canvas_surf_to_trans_surf(&image, transparent->true_color);
+    cairo_surface_destroy(surface);
+
+    surface_to_image(canvas, trans_surf, &image, 1);
+    SET_GLC_RECT(&dest, bbox);
+    SET_GLC_RECT(&src, &transparent->src_area);
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
+
+    cairo_surface_destroy(trans_surf);
+    glc_flush(canvas->glc);
+}
+
+static inline void fill_common(GLCanvas *canvas, Rect *bbox, Clip *clip, QMask * mask, GLCOp op)
+{
+    GLCRect rect;
+
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, mask, bbox->left, bbox->top);
+    glc_set_op(canvas->glc, op);
+    SET_GLC_RECT(&rect, bbox);
+    glc_fill_rect(canvas->glc, &rect);
+}
+
+void gl_canvas_draw_whiteness(GLCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness)
+{
+    fill_common(canvas, bbox, clip, &whiteness->mask, GLC_OP_SET);
+}
+
+void gl_canvas_draw_blackness(GLCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness)
+{
+    fill_common(canvas, bbox, clip, &blackness->mask, GLC_OP_CLEAR);
+}
+
+void gl_canvas_draw_invers(GLCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers)
+{
+    fill_common(canvas, bbox, clip, &invers->mask, GLC_OP_INVERT);
+}
+
+void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3)
+{
+    cairo_surface_t *d;
+    cairo_surface_t *s;
+    GLCImage image;
+    Point src_pos;
+    uint8_t *data_opp;
+    int src_stride;
+
+    set_clip(canvas, bbox, clip);
+    set_mask(canvas, &rop3->mask, bbox->left, bbox->top);
+
+    glc_set_op(canvas->glc, GLC_OP_COPY);
+
+    image.format = GLC_IMAGE_RGB32;
+    image.width = bbox->right - bbox->left;
+    image.height = bbox->bottom - bbox->top;
+
+    image.pallet = NULL;
+
+    d = cairo_image_surface_create(CAIRO_FORMAT_RGB24, image.width, image.height);
+    if (cairo_surface_status(d) != CAIRO_STATUS_SUCCESS) {
+        CANVAS_ERROR("create surface failed, %s",
+                     cairo_status_to_string(cairo_surface_status(d)));
+    }
+    image.pixels = cairo_image_surface_get_data(d);
+    image.stride = cairo_image_surface_get_stride(d);
+
+    glc_read_pixels(canvas->glc, bbox->left, bbox->top, &image);
+    data_opp = copy_opposite_image(canvas, image.pixels,
+                                   cairo_image_surface_get_stride(d),
+                                   cairo_image_surface_get_height(d));
+    memcpy(image.pixels, data_opp,
+           cairo_image_surface_get_stride(d) * cairo_image_surface_get_height(d));
+
+    s = canvas_get_image(&canvas->base, rop3->src_bitmap);
+    src_stride = cairo_image_surface_get_stride(s);
+    if (src_stride > 0) {
+        data_opp = copy_opposite_image(canvas, cairo_image_surface_get_data(s),
+                                       src_stride, cairo_image_surface_get_height(s));
+        memcpy(cairo_image_surface_get_data(s), data_opp,
+               src_stride * cairo_image_surface_get_height(s));
+    }
+
+    if (!rect_is_same_size(bbox, &rop3->src_area)) {
+        cairo_surface_t *scaled_s = canvas_scale_surface(s, &rop3->src_area, image.width,
+                                                         image.height, rop3->scale_mode);
+        cairo_surface_destroy(s);
+        s = scaled_s;
+        src_pos.x = 0;
+        src_pos.y = 0;
+    } else {
+        src_pos.x = rop3->src_area.left;
+        src_pos.y = rop3->src_area.top;
+    }
+
+    if (cairo_image_surface_get_width(s) - src_pos.x < image.width ||
+                                  cairo_image_surface_get_height(s) - src_pos.y < image.height) {
+        CANVAS_ERROR("bad src bitmap size");
+    }
+
+    if (rop3->brush.type == BRUSH_TYPE_PATTERN) {
+        cairo_surface_t *p = canvas_get_image(&canvas->base, rop3->brush.u.pattern.pat);
+        Point pat_pos;
+
+        pat_pos.x = (bbox->left - rop3->brush.u.pattern.pos.x) % cairo_image_surface_get_width(p);
+
+        pat_pos.y = (bbox->top - rop3->brush.u.pattern.pos.y) % cairo_image_surface_get_height(p);
+
+        //for now (bottom-top)
+        if (pat_pos.y < 0) {
+            pat_pos.y = cairo_image_surface_get_height(p) + pat_pos.y;
+        }
+        pat_pos.y = (image.height + pat_pos.y) % cairo_image_surface_get_height(p);
+        pat_pos.y = cairo_image_surface_get_height(p) - pat_pos.y;
+
+        do_rop3_with_pattern(rop3->rop3, d, s, &src_pos, p, &pat_pos);
+        cairo_surface_destroy(p);
+    } else {
+        uint32_t color = (canvas->base.color_shift) == 8 ? rop3->brush.u.color :
+                                                         canvas_16bpp_to_32bpp(rop3->brush.u.color);
+        do_rop3_with_color(rop3->rop3, d, s, &src_pos, color);
+    }
+
+    cairo_surface_destroy(s);
+
+    GLCRecti dest;
+    GLCRecti src;
+    dest.x = bbox->left;
+    dest.y = bbox->top;
+
+    image.pixels = copy_opposite_image(canvas, image.pixels, cairo_image_surface_get_stride(d),
+                                       cairo_image_surface_get_height(d));
+
+    src.x = src.y = 0;
+    dest.width = src.width = image.width;
+    dest.height = src.height = image.height;
+    glc_draw_image(canvas->glc, &dest, &src, &image, 0, 1);
+    cairo_surface_destroy(d);
+}
+
+void gl_canvas_draw_stroke(GLCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke)
+{
+    GLCPath path;
+
+    set_clip(canvas, bbox, clip);
+    glc_clear_mask(canvas->glc, GLC_MASK_A);
+    set_op(canvas, stroke->fore_mode);
+    set_brush(canvas, &stroke->brush);
+
+    if (stroke->attr.flags & LINE_ATTR_STYLED) {
+        WARN("LINE_ATTR_STYLED");
+    }
+    glc_set_line_width(canvas->glc, fix_to_double(stroke->attr.width));
+
+    path = get_path(canvas, GET_ADDRESS(stroke->path));
+    glc_stroke_path(canvas->glc, path);
+    glc_path_destroy(path);
+}
+
+void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text)
+{
+    GLCRect rect;
+    String *str;
+
+    set_clip(canvas, bbox, clip);
+    glc_clear_mask(canvas->glc, GLC_MASK_A);
+
+    if (!rect_is_empty(&text->back_area)) {
+        set_brush(canvas, &text->back_brush);
+        set_op(canvas, text->back_mode);
+        SET_GLC_RECT(&rect, bbox);
+        glc_fill_rect(canvas->glc, &rect);
+    }
+
+    str = (String *)GET_ADDRESS(text->str);
+    set_brush(canvas, &text->fore_brush);
+    set_op(canvas, text->fore_mode);
+    if (str->flags & STRING_RASTER_A1) {
+        Point pos;
+        cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 1, &pos);
+        _glc_fill_mask(canvas->glc, pos.x, pos.y,
+                       cairo_image_surface_get_width(mask),
+                       cairo_image_surface_get_height(mask),
+                       cairo_image_surface_get_stride(mask),
+                       cairo_image_surface_get_data(mask));
+        cairo_surface_destroy(mask);
+    } else if (str->flags & STRING_RASTER_A4) {
+        Point pos;
+        cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 4, &pos);
+        glc_fill_alpha(canvas->glc, pos.x, pos.y,
+                       cairo_image_surface_get_width(mask),
+                       cairo_image_surface_get_height(mask),
+                       cairo_image_surface_get_stride(mask),
+                       cairo_image_surface_get_data(mask));
+
+        cairo_surface_destroy(mask);
+    } else if (str->flags & STRING_RASTER_A8) {
+        WARN("untested path A8 glyphs, doing nothing");
+        if (0) {
+            Point pos;
+            cairo_surface_t *mask = canvas_get_str_mask(&canvas->base, str, 8, &pos);
+            glc_fill_alpha(canvas->glc, pos.x, pos.y,
+                           cairo_image_surface_get_width(mask),
+                           cairo_image_surface_get_height(mask),
+                           cairo_image_surface_get_stride(mask),
+                           cairo_image_surface_get_data(mask));
+            cairo_surface_destroy(mask);
+        }
+    } else {
+        WARN("untested path vector glyphs, doing nothing");
+        if (0) {
+            //draw_vector_str(canvas, str, &text->fore_brush, text->fore_mode);
+        }
+    }
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_clear(GLCanvas *canvas)
+{
+    glc_clear(canvas->glc);
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_copy_pixels(GLCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos)
+{
+    set_clip(canvas, bbox, clip);
+    glc_clear_mask(canvas->glc, GLC_MASK_A);
+    glc_set_op(canvas->glc, GLC_OP_COPY);
+    glc_copy_pixels(canvas->glc, bbox->left, bbox->top, src_pos->x, src_pos->y,
+                    bbox->right - bbox->left, bbox->bottom - bbox->top);
+}
+
+void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area)
+{
+    GLCImage image;
+
+    ASSERT(dest_stride > 0);
+    image.format = GLC_IMAGE_RGB32;
+    image.height = area->bottom - area->top;
+    image.width = area->right - area->left;
+    image.pixels = dest;
+    image.stride = dest_stride;
+    glc_read_pixels(canvas->glc, area->left, area->top, &image);
+}
+
+void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const Rect *rects)
+{
+    GLCRect *glc_rects = (GLCRect *)malloc(num_rect * sizeof(GLCRect));
+    GLCRect *now = glc_rects;
+    GLCRect *end = glc_rects + num_rect;
+
+    for (; now < end; now++, rects++) {
+        SET_GLC_RECT(now, rects);
+    }
+    glc_mask_rects(canvas->glc, num_rect, glc_rects, GLC_MASK_B);
+
+    free(glc_rects);
+}
+
+void gl_canvas_put_image(GLCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+                         uint32_t src_width, uint32_t src_height, int src_stride,
+                         const QRegion *clip)
+{
+    GLCRecti src;
+    GLCRecti gldest;
+    GLCImage image;
+    uint32_t i;
+
+    ASSERT(src_stride <= 0)
+    glc_clip_reset(canvas->glc);
+
+    if (clip) {
+        GLCRect rect;
+        if (clip->num_rects == 0) {
+            rect.x = rect.y = rect.width = rect.height = 0;
+            glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
+        } else {
+            SET_GLC_RECT(&rect, clip->rects);
+            glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_SET);
+            for (i = 1; i < clip->num_rects; i++) {
+                SET_GLC_RECT(&rect, clip->rects + i);
+                glc_clip_rect(canvas->glc, &rect, GLC_CLIP_OP_OR);
+            }
+        }
+    }
+
+    SET_GLC_RECT(&gldest, dest);
+    src.x = src.y = 0;
+    src.width = src_width;
+    src.height = src_height;
+
+    image.format = GLC_IMAGE_RGB32;
+    image.width = src_width;
+    image.height = src_height;
+    src_stride = -src_stride;
+    image.stride = src_stride;
+    image.pixels = (uint8_t *)src_data - (src_height - 1) * src_stride;
+    image.pallet = NULL;
+    glc_draw_image(canvas->glc, &gldest, &src, &image, 0, 1);
+
+    glc_flush(canvas->glc);
+}
+
+void gl_canvas_clear_top_mask(GLCanvas *canvas)
+{
+    glc_clear_mask(canvas->glc, GLC_MASK_B);
+}
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void gl_canvas_set_access_params(GLCanvas *canvas, ADDRESS delta, unsigned long base,
+                                 unsigned long max)
+{
+    __canvas_set_access_params(&canvas->base, delta, base, max);
+}
+
+#else
+void gl_canvas_set_access_params(GLCanvas *canvas, ADDRESS delta)
+{
+    __canvas_set_access_params(&canvas->base, delta);
+}
+
+#endif
+
+void *gl_canvas_get_usr_data(GLCanvas *canvas)
+{
+    return canvas->usr_data;
+}
+
+static int need_init = 1;
+
+#ifdef CAIRO_CANVAS_CACHE
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put,
+                           bits_cache_get_fn_t bits_cache_get,
+                           void *palette_cache_opaque,
+                           palette_cache_put_fn_t palette_cache_put,
+                           palette_cache_get_fn_t palette_cache_get,
+                           palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put,
+                           bits_cache_get_fn_t bits_cache_get
+#else
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth
+#endif
+#ifdef USE_GLZ
+                           , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                           )
+{
+    GLCanvas *canvas;
+    int init_ok;
+
+    if (need_init || !(canvas = (GLCanvas *)malloc(sizeof(GLCanvas)))) {
+        return NULL;
+    }
+    memset(canvas, 0, sizeof(GLCanvas));
+
+    if (!(canvas->glc = glc_create(width, height))) {
+        goto error_1;
+    }
+    canvas->usr_data = usr_data;
+    canvas->private_data = NULL;
+#ifdef CAIRO_CANVAS_CACHE
+    init_ok = canvas_base_init(&canvas->base, depth,
+                               bits_cache_opaque,
+                               bits_cache_put,
+                               bits_cache_get,
+                               palette_cache_opaque,
+                               palette_cache_put,
+                               palette_cache_get,
+                               palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+    init_ok = canvas_base_init(&canvas->base, depth,
+                               bits_cache_opaque,
+                               bits_cache_put,
+                               bits_cache_get
+#else
+    init_ok = canvas_base_init(&canvas->base, depth
+#endif
+#ifdef USE_GLZ
+                               ,
+                               glz_decoder_opaque,
+                               glz_decode
+#endif
+                               );
+    if (!init_ok) {
+        goto error_2;
+    }
+
+    return canvas;
+
+error_2:
+    glc_destroy(canvas->glc, 0);
+error_1:
+    free(canvas);
+
+    return NULL;
+}
+
+void gl_canvas_destroy(GLCanvas *canvas, int textures_lost)
+{
+    if (!canvas) {
+        return;
+    }
+    canvas_base_destroy(&canvas->base);
+    glc_destroy(canvas->glc, textures_lost);
+    if (canvas->private_data) {
+        free(canvas->private_data);
+    }
+    free(canvas);
+}
+
+void gl_canvas_init() //unsafe global function
+{
+    if (!need_init) {
+        return;
+    }
+    need_init = 0;
+    rop3_init(); 
+}
diff --git a/common/gl_canvas.h b/common/gl_canvas.h
new file mode 100644
index 00000000..b9a4eb89
--- /dev/null
+++ b/common/gl_canvas.h
@@ -0,0 +1,83 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "glc.h"
+#include "draw.h"
+#include "canvas_base.h"
+#include "region.h"
+
+typedef struct GLCanvas GLCanvas;
+
+void gl_canvas_draw_fill(GLCanvas *canvas, Rect *bbox, Clip *clip, Fill *fill);
+void gl_canvas_draw_copy(GLCanvas *canvas, Rect *bbox, Clip *clip, Copy *copy);
+void gl_canvas_draw_opaque(GLCanvas *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
+void gl_canvas_draw_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, Blend *blend);
+void gl_canvas_draw_alpha_blend(GLCanvas *canvas, Rect *bbox, Clip *clip, AlphaBlnd *alpha_blend);
+void gl_canvas_draw_transparent(GLCanvas *canvas, Rect *bbox, Clip *clip, Transparent *transparent);
+void gl_canvas_draw_whiteness(GLCanvas *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
+void gl_canvas_draw_blackness(GLCanvas *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
+void gl_canvas_draw_invers(GLCanvas *canvas, Rect *bbox, Clip *clip, Invers *invers);
+void gl_canvas_draw_rop3(GLCanvas *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
+void gl_canvas_draw_stroke(GLCanvas *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
+void gl_canvas_draw_text(GLCanvas *canvas, Rect *bbox, Clip *clip, Text *text);
+
+void gl_canvas_copy_pixels(GLCanvas *canvas, Rect *bbox, Clip *clip, Point *src_pos);
+void gl_canvas_read_pixels(GLCanvas *canvas, uint8_t *dest, int dest_stride, const Rect *area);
+
+void gl_canvas_put_image(GLCanvas *canvas, const Rect *dest, const uint8_t *src_data,
+                         uint32_t src_width, uint32_t src_height, int src_stride,
+                         const QRegion *clip);
+
+void gl_canvas_clear(GLCanvas *canvas);
+
+void gl_canvas_set_top_mask(GLCanvas *canvas, int num_rect, const Rect *rects);
+void gl_canvas_clear_top_mask(GLCanvas *canvas);
+
+#ifdef CAIRO_CANVAS_ACCESS_TEST
+void gl_canvas_set_access_params(GLCanvas *canvas, ADDRESS delta, unsigned long base,
+                                 unsigned long max);
+#else
+void gl_canvas_set_access_params(GLCanvas *canvas, ADDRESS delta);
+#endif
+
+void *gl_canvas_get_usr_data(GLCanvas *canvas);
+
+#ifdef CAIRO_CANVAS_CACHE
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put,
+                           bits_cache_get_fn_t bits_cache_get,
+                           void *palette_cache_opaque,
+                           palette_cache_put_fn_t palette_cache_put,
+                           palette_cache_get_fn_t palette_cache_get,
+                           palette_cache_release_fn_t palette_cache_release
+#elif defined(CAIRO_CANVAS_IMAGE_CACHE)
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth,
+                           void *bits_cache_opaque,
+                           bits_cache_put_fn_t bits_cache_put,
+                           bits_cache_get_fn_t bits_cache_get
+#else
+GLCanvas *gl_canvas_create(void *usr_data, int width, int height, int depth
+#endif
+#ifdef USE_GLZ
+                           , void *glz_decoder_opaque, glz_decode_fn_t glz_decode
+#endif
+                           );
+void gl_canvas_destroy(GLCanvas *, int);
+
+void gl_canvas_init();
+
diff --git a/common/gl_utils.h b/common/gl_utils.h
new file mode 100644
index 00000000..41266775
--- /dev/null
+++ b/common/gl_utils.h
@@ -0,0 +1,85 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef GL_UTILS_H
+#define GL_UTILS_H
+
+#ifdef RED_DEBUG
+#define GLC_ERROR_TEST_FLUSH {                                        \
+    GLenum gl_err;  glFlush();                                        \
+    if ((gl_err = glGetError()) != GL_NO_ERROR) {                     \
+        printf("%s[%d]: opengl error: %s\n",  __FUNCTION__, __LINE__, \
+        gluErrorString(gl_err));                                      \
+        abort();                                                      \
+    }                                                                 \
+}
+
+#define GLC_ERROR_TEST_FINISH {                                       \
+    GLenum gl_err;  glFinish();                                       \
+    if ((gl_err = glGetError()) != GL_NO_ERROR) {                     \
+        printf("%s[%d]: opengl error: %s\n",  __FUNCTION__, __LINE__, \
+        gluErrorString(gl_err));                                      \
+        abort();                                                      \
+    }                                                                 \
+}
+#else
+#define GLC_ERROR_TEST_FLUSH ;
+
+#define GLC_ERROR_TEST_FINISH ;
+#endif
+
+#ifdef WIN32
+static inline int find_msb(uint32_t val)
+{
+    uint32_t r;
+    __asm {
+        bsr eax, val
+        jnz found
+        mov eax, -1
+
+found:
+        mov r, eax
+    }
+    return r + 1;
+}
+
+#else
+static inline int find_msb(unsigned int val)
+{
+    int ret;
+
+    asm ("bsrl %1,%0\n\t"
+         "jnz 1f\n\t"
+         "movl $-1,%0\n"
+         "1:"
+         : "=r"(ret) : "r"(val));
+    return ret + 1;
+}
+
+#endif
+
+static inline int gl_get_to_power_two(unsigned int val)
+{
+    if ((val & (val - 1)) == 0) {
+        return val;
+    }
+    return 1 << find_msb(val);
+}
+
+#endif
diff --git a/common/glc.c b/common/glc.c
new file mode 100644
index 00000000..5300ebdc
--- /dev/null
+++ b/common/glc.c
@@ -0,0 +1,1582 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#define GL_GLEXT_PROTOTYPES
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glext.h>
+
+#ifdef WIN32
+#include "glext.h"
+#include "wglext.h"
+#endif
+
+#include "glc.h"
+#include "gl_utils.h"
+
+#define TRUE 1
+#define FALSE 0
+
+#define ASSERT(x) if (!(x)) {printf("%s: assert failed %s\n", __FUNCTION__, #x); abort();}
+
+#define WARN_ONCE(x) {      \
+    static int warn = TRUE; \
+    if (warn) {             \
+        printf x;           \
+        warn = FALSE;       \
+    }                       \
+}
+
+#define TESS_VERTEX_ALLOC_BUNCH 20
+
+typedef struct InternaCtx InternaCtx;
+typedef struct InternalPat {
+    InternaCtx *owner;
+    int refs;
+    GLuint texture;
+    int x_orign;
+    int y_orign;
+    int width;
+    int height;
+} InternalPat;
+
+typedef struct Pathpath {
+    int start_point;
+    int num_segments;
+} Path;
+
+enum  {
+    GLC_PATH_SEG_LINES,
+    GLC_PATH_SEG_BEIZER,
+};
+
+//todo: flatten cache
+typedef struct PathSegment {
+    int type;
+    int count;
+} PathSegment;
+
+typedef struct PathPoint {
+    double x;
+    double y;
+    double z;
+} PathPoint;
+
+typedef GLdouble Vertex[3];
+
+typedef struct InternalPath {
+    InternaCtx *owner;
+
+    Path *paths;
+    int paths_size;
+    int paths_pos;
+
+    PathSegment *segments;
+    int segments_size;
+    int segments_pos;
+
+    PathPoint *points;
+    int points_size;
+    int points_pos;
+
+    Path *current_path;
+    PathSegment *current_segment;
+} InternalPath;
+
+typedef struct TassVertex TassVertex;
+struct TassVertex {
+    PathPoint point;
+    TassVertex *list_link;
+    TassVertex *next;
+};
+
+typedef struct TassVertexBuf TassVertexBuf;
+struct TassVertexBuf {
+    TassVertexBuf *next;
+    TassVertex vertexs[0];
+};
+
+#define USE_LINE_ANTIALIAS 0
+
+typedef struct LineDash {
+    double *dashes;
+    int num_dashes;
+    double offset;
+    int cur_dash;
+    double dash_pos;
+} LineDash;
+
+enum  {
+    GLC_STROKE_NONACTIVE,
+    GLC_STROKE_FIRST,
+    GLC_STROKE_ACTIVE,
+};
+
+typedef struct PathStroke {
+    double x;
+    double y;
+    int state;
+} PathStroke;
+
+struct InternaCtx {
+    int draw_mode;
+    int stencil_refs;
+    int stencil_mask;
+    int width;
+    int height;
+    GLfloat line_width;
+    LineDash line_dash;
+    PathStroke path_stroke;
+    InternalPat *pat;
+    int max_texture_size;
+    GLUtesselator* tesselator;
+    TassVertex *free_tess_vertex;
+    TassVertex *used_tess_vertex;
+    TassVertexBuf *vertex_bufs;
+    int private_tex_width;
+    int private_tex_height;
+    GLuint private_tex;
+#ifdef WIN32
+    PFNGLBLENDEQUATIONPROC glBlendEquation;
+#endif
+};
+
+#define Y(y) -(y)
+#define VERTEX2(x, y) glVertex2d(x, Y(y))
+
+static void fill_rect(InternaCtx *ctx, void *rect);
+static void fill_path(InternaCtx *ctx, void *path);
+static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height, int stride,
+                      const uint8_t *bitmap);
+static void set_pat(InternaCtx *ctx, InternalPat *pat);
+
+static inline void *zmalloc(size_t size)
+{
+    return calloc(1, size);
+}
+
+static inline void set_raster_pos(InternaCtx *ctx, int x, int y)
+{
+    if (x >= 0 && y >= 0 && x < ctx->width && y < ctx->height) {
+        glRasterPos2i(x, Y(y));
+        return;
+    }
+    glRasterPos2i(0, 0);
+    glBitmap(0, 0, 0, 0, (GLfloat)x, (GLfloat)Y(y), NULL);
+}
+
+static TassVertex *alloc_tess_vertex(InternaCtx *ctx)
+{
+    TassVertex *vertex;
+
+    if (!ctx->free_tess_vertex) {
+        TassVertexBuf *buf;
+        int i;
+
+        if (!(buf = (TassVertexBuf *)malloc(sizeof(TassVertexBuf) +
+                                            sizeof(TassVertex) * TESS_VERTEX_ALLOC_BUNCH))) {
+            //warn
+            return NULL;
+        }
+        buf->next = ctx->vertex_bufs;
+        ctx->vertex_bufs = buf;
+        for (i = 0; i < TESS_VERTEX_ALLOC_BUNCH; i++) {
+            buf->vertexs[i].point.z = 0;
+            buf->vertexs[i].next = ctx->free_tess_vertex;
+            ctx->free_tess_vertex = &buf->vertexs[i];
+        }
+    }
+
+    vertex = ctx->free_tess_vertex;
+    ctx->free_tess_vertex = vertex->next;
+    vertex->next = ctx->used_tess_vertex;
+    ctx->used_tess_vertex = vertex;
+    return vertex;
+}
+
+static void reset_tass_vertex(InternaCtx *ctx)
+{
+    TassVertex *vertex;
+    while ((vertex = ctx->used_tess_vertex)) {
+        ctx->used_tess_vertex = vertex->next;
+        vertex->next = ctx->free_tess_vertex;
+        ctx->free_tess_vertex = vertex;
+    }
+}
+
+static void free_tass_vertex_bufs(InternaCtx *ctx)
+{
+    TassVertexBuf *buf;
+
+    ctx->used_tess_vertex = NULL;
+    ctx->free_tess_vertex = NULL;
+    while ((buf = ctx->vertex_bufs)) {
+        ctx->vertex_bufs = buf->next;
+        free(buf);
+    }
+}
+
+//naiev bezier flattener
+static TassVertex *bezier_flattener(InternaCtx *ctx, PathPoint *points)
+{
+    double ax, bx, cx;
+    double ay, by, cy;
+    const int num_points = 30;
+    double dt;
+    int i;
+
+    TassVertex *vertex_list = NULL;
+    TassVertex *curr_vertex;
+
+    for (i = 0; i < num_points - 2; i++) {
+        TassVertex *vertex;
+
+        if (!(vertex = alloc_tess_vertex(ctx))) {
+            //warn
+            return NULL;
+        }
+        vertex->list_link = vertex_list;
+        vertex_list = vertex;
+    }
+
+    curr_vertex = vertex_list;
+
+    cx = 3.0 * (points[1].x - points[0].x);
+    bx = 3.0 * (points[2].x - points[1].x) - cx;
+    ax = points[3].x - points[0].x - cx - bx;
+
+    cy = 3.0 * (points[1].y - points[0].y);
+    by = 3.0 * (points[2].y - points[1].y) - cy;
+    ay = points[3].y - points[0].y - cy - by;
+
+    dt = 1.0 / (num_points - 1);
+
+    for (i = 1; i < num_points - 1; i++, curr_vertex = curr_vertex->list_link) {
+        double tSquared, tCubed;
+        double t;
+        t = i * dt;
+
+        tSquared = t * t;
+        tCubed = tSquared * t;
+
+        curr_vertex->point.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + points[0].x;
+        curr_vertex->point.y = (ay * tCubed) + (by * tSquared) + (cy * t) + points[0].y;
+    }
+
+    return vertex_list;
+}
+
+#define MORE_X(path, Type, name) {                                              \
+    Type *name;                                                                 \
+                                                                                \
+    if (!(name = (Type *)zmalloc(sizeof(*name) * path->name##_size * 2))) {     \
+        return FALSE;                                                           \
+    }                                                                           \
+    memcpy(name, path->name, sizeof(*name) * path->name##_size);                \
+    free(path->name);                                                           \
+    path->name = name;                                                          \
+    path->name##_size *= 2;                                                     \
+    return TRUE;                                                                \
+}
+
+static int more_points(InternalPath *path)
+{
+    MORE_X(path, PathPoint, points);
+}
+
+static int more_segments(InternalPath *path)
+{
+    MORE_X(path, PathSegment, segments);
+}
+
+static int more_paths(InternalPath *path)
+{
+    MORE_X(path, Path, paths);
+}
+
+static inline void put_point(InternalPath *path, double x, double y)
+{
+    path->points[path->points_pos].x = x;
+    path->points[path->points_pos].y = Y(y + 0.5);
+    path->points[path->points_pos++].z = 0;
+}
+
+void glc_path_move_to(GLCPath path, double x, double y)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    ASSERT(internal);
+
+    if (internal->current_segment) {
+        internal->current_segment = NULL;
+        internal->current_path = NULL;
+        if (internal->points_pos == internal->points_size && !more_points(internal)) {
+            //warn
+            return;
+        }
+        internal->points_pos++;
+    }
+    internal->points[internal->points_pos - 1].x = x;
+    internal->points[internal->points_pos - 1].y = Y(y + 0.5);
+    internal->points[internal->points_pos - 1].z = 0;
+}
+
+static int add_segment_common(InternalPath *internal, int type, int num_points)
+{
+    if (internal->points_size - internal->points_pos < num_points && !more_points(internal)) {
+        //warn
+        return FALSE;
+    }
+
+    if (internal->current_segment) {
+        if (internal->current_segment->type == type) {
+            internal->current_segment->count++;
+            return TRUE;
+        }
+        if (internal->segments_pos == internal->segments_size && !more_segments(internal)) {
+            //warn
+            return FALSE;
+        }
+        internal->current_segment = &internal->segments[internal->segments_pos++];
+        internal->current_segment->type = type;
+        internal->current_segment->count = 1;
+        internal->current_path->num_segments++;
+        return TRUE;
+    }
+
+    if (internal->paths_pos == internal->paths_size && !more_paths(internal)) {
+        //warn
+        return FALSE;
+    }
+
+    if (internal->segments_pos == internal->segments_size && !more_segments(internal)) {
+        //warn
+        return FALSE;
+    }
+
+    internal->current_path = &internal->paths[internal->paths_pos++];
+    internal->current_path->start_point = internal->points_pos - 1;
+    internal->current_path->num_segments = 1;
+    internal->current_segment = &internal->segments[internal->segments_pos++];
+    internal->current_segment->type = type;
+    internal->current_segment->count = 1;
+    return TRUE;
+}
+
+void glc_path_line_to(GLCPath path, double x, double y)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    ASSERT(internal);
+
+    if (!add_segment_common(internal, GLC_PATH_SEG_LINES, 1)) {
+        return;
+    }
+    put_point(internal, x, y);
+}
+
+void glc_path_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
+                       double p3_x, double p3_y)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    ASSERT(internal);
+
+    if (!add_segment_common(internal, GLC_PATH_SEG_BEIZER, 3)) {
+        return;
+    }
+    put_point(internal, p1_x, p1_y);
+    put_point(internal, p2_x, p2_y);
+    put_point(internal, p3_x, p3_y);
+}
+
+void glc_path_close(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    ASSERT(internal);
+    if (!internal->current_path) {
+        return;
+    }
+    PathPoint *end_point = &internal->points[internal->current_path->start_point];
+    glc_path_line_to(path, end_point->x, Y(end_point->y));
+    glc_path_move_to(path, end_point->x, Y(end_point->y));
+}
+
+void glc_path_cleare(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    ASSERT(internal);
+    internal->paths_pos = internal->segments_pos = 0;
+    internal->current_segment = NULL;
+    internal->current_path = NULL;
+
+    internal->points[0].x = 0;
+    internal->points[0].y = 0;
+    internal->points_pos = 1;
+}
+
+GLCPath glc_path_create(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPath *path;
+
+    ASSERT(ctx);
+    if (!(path = (InternalPath *)zmalloc(sizeof(*path)))) {
+        return NULL;
+    }
+
+    path->paths = (Path *)malloc(sizeof(*path->paths) * (path->paths_size = 2));
+    if (!path->paths) {
+        goto error_1;
+    }
+
+    path->segments = (PathSegment *)malloc(sizeof(*path->segments) * (path->segments_size = 4));
+    if (!path->segments) {
+        goto error_2;
+    }
+
+    path->points = (PathPoint *)malloc(sizeof(*path->points) * (path->points_size = 20));
+    if (!path->points) {
+        goto error_3;
+    }
+
+    path->owner = ctx;
+    path->points_pos = 1;
+    return path;
+
+error_3:
+    free(path->segments);
+
+error_2:
+    free(path->paths);
+
+error_1:
+    free(path);
+
+    return NULL;
+}
+
+void glc_path_destroy(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+
+    if (!path) {
+        return;
+    }
+
+    free(internal->points);
+    free(internal->segments);
+    free(internal->paths);
+    free(internal);
+}
+
+static inline void unref_pat(InternalPat *pat)
+{
+    if (!pat) {
+        return;
+    }
+    ASSERT(pat->refs > 0);
+    if (--pat->refs == 0) {
+        glFinish();
+        glDeleteTextures(1, &pat->texture);
+        free(pat);
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static inline InternalPat *ref_pat(InternalPat *pat)
+{
+    pat->refs++;
+    return pat;
+}
+
+static void scale(uint32_t *dest, uint32_t dest_width, uint32_t dest_height,
+                  uint32_t *src, uint32_t src_width, uint32_t src_height, int src_stride)
+{
+    double x_scale = (double)src_width / dest_width;
+    double y_scale = (double)src_height / dest_height;
+    uint32_t i;
+    uint32_t j;
+    int prev_row = -1;
+
+    for (i = 0; i < dest_height; i++) {
+        int row = (int)(y_scale * i);
+        if (row == prev_row) {
+            memcpy(dest, dest - dest_width, dest_width * sizeof(uint32_t));
+            dest += dest_width;
+            continue;
+        }
+        for (j = 0; j < dest_width; j++) {
+            int col = (int)(x_scale * j);
+            *(dest++) = *(src + col);
+        }
+        prev_row = row;
+        src = (uint32_t *)((uint8_t *)src + src_stride);
+    }
+}
+
+static inline void init_pattern(InternalPat *pat, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternaCtx *ctx = pat->owner;
+    uint32_t *tmp_pixmap = NULL;
+    int width;
+    int height;
+    int width2;
+    int height2;
+
+    const int pix_bytes = 4;
+
+    ASSERT(image->format == GLC_IMAGE_RGB32); //for now
+
+    width = image->width;
+    height = image->height;
+    width2 = gl_get_to_power_two(width);
+    height2 = gl_get_to_power_two(height);
+
+    ASSERT(width > 0 && height > 0);
+    ASSERT(width > 0 && width <= pat->owner->max_texture_size);
+    ASSERT(height > 0 && height <= pat->owner->max_texture_size);
+
+    if (width2 != width || height2 != height) {
+        if (!(tmp_pixmap = (uint32_t *)malloc(width2 * height2 * sizeof(uint32_t)))) {
+            //warn
+            return;
+        }
+        scale(tmp_pixmap, width2, height2, (uint32_t *)image->pixels, width, height, image->stride);
+    }
+
+    glBindTexture(GL_TEXTURE_2D, pat->texture);
+
+    //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    if (tmp_pixmap) {
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, width2);
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, width2, height2, 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                     tmp_pixmap);
+        free(tmp_pixmap);
+    } else {
+        ASSERT(image->stride % pix_bytes == 0);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                     image->pixels);
+    }
+
+    GLC_ERROR_TEST_FLUSH;
+    pat->x_orign = x_orign % width;
+    pat->y_orign = y_orign % height;
+    pat->width = width;
+    pat->height = height;
+
+    if (ctx->pat == pat) {
+        set_pat(pat->owner, pat);
+    } else if (ctx->pat) {
+        glBindTexture(GL_TEXTURE_2D, ctx->pat->texture);
+    }
+}
+
+GLCPattern glc_pattern_create(GLCCtx glc, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPat *pat;
+
+    ASSERT(ctx && image);
+
+    if (!(pat = (InternalPat *)zmalloc(sizeof(*pat)))) {
+        return NULL;
+    }
+    pat->refs = 1;
+    pat->owner = ctx;
+    glGenTextures(1, &pat->texture);
+    init_pattern(pat, x_orign, y_orign, image);
+    return pat;
+}
+
+void glc_pattern_set(GLCPattern pattern, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternalPat *pat = (InternalPat *)pattern;
+    ASSERT(pat && pat->owner);
+
+    glFinish();
+    init_pattern(pat, x_orign, y_orign, image);
+}
+
+void glc_pattern_destroy(GLCPattern pat)
+{
+    unref_pat((InternalPat *)pat);
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void set_pat(InternaCtx *ctx, InternalPat *pat)
+{
+    pat = ref_pat(pat);
+    unref_pat(ctx->pat);
+    ctx->pat = pat;
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, pat->texture);
+
+    GLfloat s_gen_params[] = { (GLfloat)1.0 / pat->width, 0, 0, 0 };
+    GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / (GLfloat)pat->height, 0, 0 };
+    glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
+    glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
+
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef((float)pat->x_orign / pat->width, (float)Y(pat->y_orign) / pat->height, 0);
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_set_pattern(GLCCtx glc, GLCPattern pattern)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPat *pat = (InternalPat *)pattern;
+
+    ASSERT(ctx && pat && pat->owner == ctx);
+    set_pat(ctx, pat);
+}
+
+void glc_set_rgb(GLCCtx glc, double red, double green, double blue)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+
+    glDisable(GL_TEXTURE_2D);
+    unref_pat(ctx->pat);
+    ctx->pat = NULL;
+    glColor4d(red, green, blue, 1);
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_set_op(GLCCtx glc, GLCOp op)
+{
+    if (op == GL_COPY) {
+        glDisable(GL_COLOR_LOGIC_OP);
+        return;
+    }
+    glLogicOp(op);
+    glEnable(GL_COLOR_LOGIC_OP);
+}
+
+void glc_set_line_width(GLCCtx glc, double width)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+    ctx->line_width = (GLfloat)width;
+    if (ctx->line_width > 0) {
+        glLineWidth(ctx->line_width);
+    } else {
+        ctx->line_width = 0;
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_set_line_dash(GLCCtx glc, const double *dashes, int num_dashes, double offset)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+    if (dashes && num_dashes >= 0 && offset >= 0) {
+        ctx->line_dash.dashes = (double *)malloc(sizeof(double) * num_dashes);
+        if (!ctx->line_dash.dashes) {
+            // FIXME: error
+            return;
+        }
+        memcpy(ctx->line_dash.dashes, dashes, sizeof(double) * num_dashes);
+        ctx->line_dash.num_dashes = num_dashes;
+        ctx->line_dash.offset = offset;
+        ctx->line_dash.cur_dash = offset ? -1 : 0;
+        ctx->line_dash.dash_pos = 0;
+    } else {
+        free(ctx->line_dash.dashes);
+        memset(&ctx->line_dash, 0, sizeof(ctx->line_dash));
+    }
+}
+
+void glc_set_fill_mode(GLCCtx glc, GLCFillMode fill_mode)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+    int mode;
+    switch (fill_mode) {
+    case GLC_FILL_MODE_WINDING_ODD:
+        mode = GLU_TESS_WINDING_ODD;
+        break;
+    case GLC_FILL_MODE_WINDING_NONZERO:
+        mode = GLU_TESS_WINDING_NONZERO;
+        break;
+    default:
+        //warn
+        return;
+    }
+    gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, mode);
+}
+
+static inline void add_stencil_client(InternaCtx *ctx)
+{
+    if (!ctx->stencil_refs) {
+        glEnable(GL_STENCIL_TEST);
+    }
+    ctx->stencil_refs++;
+}
+
+static inline void remove_stencil_client(InternaCtx *ctx)
+{
+    ctx->stencil_refs--;
+    if (!ctx->stencil_refs) {
+        glDisable(GL_STENCIL_TEST);
+    }
+}
+
+void glc_set_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
+                  int stride, const uint8_t *bitmap, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    ASSERT(ctx && bitmap);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+
+    glDisable(GL_BLEND);
+
+    if (!(ctx->stencil_mask & mask)) {
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= mask;
+    }
+
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+    glStencilMask(mask);
+    glClear(GL_STENCIL_BUFFER_BIT);
+
+    glStencilFunc(GL_ALWAYS, mask, mask);
+    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
+}
+
+void glc_mask_rects(GLCCtx glc, int num_rect, GLCRect *rects, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    GLCRect *end;
+    ASSERT(ctx && rects);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+
+    glDisable(GL_BLEND);
+
+    if (!(ctx->stencil_mask & mask)) {
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= mask;
+    }
+
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+    glStencilMask(mask);
+    glClear(GL_STENCIL_BUFFER_BIT);
+
+    glStencilFunc(GL_ALWAYS, mask, mask);
+    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    end = rects + num_rect;
+    for (; rects < end; rects++) {
+        fill_rect(ctx, rects);
+    }
+}
+
+void glc_clear_mask(GLCCtx glc, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    ASSERT(ctx);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+
+    if ((ctx->stencil_mask & mask)) {
+        ctx->stencil_mask &= ~mask;
+        remove_stencil_client(ctx);
+    }
+}
+
+void glc_clip_reset(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    if (!(ctx->stencil_mask & 0x03)) {
+        return;
+    }
+    remove_stencil_client(ctx);
+    ctx->stencil_mask &= ~0x03;
+    glStencilMask(0x03);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void clip_common(InternaCtx *ctx, GLCClipOp op, void (*fill_func)(InternaCtx *, void *),
+                        void *data)
+{
+    int stencil_val;
+
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    glDisable(GL_BLEND);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+
+    if (op == GLC_CLIP_OP_SET) {
+        glc_clip_reset(ctx);
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= 0x01;
+    } else if (!(ctx->stencil_mask & 0x03)) {
+        GLCRect area;
+        if (op == GLC_CLIP_OP_OR) {
+            return;
+        }
+        area.x = area.y = 0;
+        area.width = ctx->width;
+        area.height = ctx->height;
+        clip_common(ctx, GLC_CLIP_OP_SET, fill_rect, &area);
+    }
+    glStencilMask(0x03);
+    switch (op) {
+    case GLC_CLIP_OP_SET:
+    case GLC_CLIP_OP_OR:
+        stencil_val = ctx->stencil_mask & 0x03;
+        glStencilFunc(GL_ALWAYS, stencil_val, stencil_val);
+        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+        fill_func(ctx, data);
+        break;
+    case GLC_CLIP_OP_AND: {
+        int clear_mask;
+        stencil_val = ctx->stencil_mask & 0x03;
+        glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
+        if (stencil_val == 0x01) {
+            glStencilOp(GL_ZERO, GL_INCR, GL_INCR);
+            stencil_val = 0x02;
+            clear_mask = 0x01;
+        } else {
+            glStencilOp(GL_ZERO, GL_DECR, GL_DECR);
+            stencil_val = 0x01;
+            clear_mask = 0x02;
+        }
+        fill_func(ctx, data);
+
+        glStencilMask(clear_mask);
+        glClear(GL_STENCIL_BUFFER_BIT);
+        ctx->stencil_mask = (ctx->stencil_mask & ~clear_mask) | stencil_val;
+        break;
+    }
+    case GLC_CLIP_OP_EXCLUDE:
+        stencil_val = ctx->stencil_mask & 0x03;
+        glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
+        glStencilOp(GL_KEEP, GL_ZERO, GL_ZERO);
+        fill_func(ctx, data);
+        break;
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_clip_rect(GLCCtx glc, const GLCRect *rect, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx && rect);
+    clip_common(ctx, op, fill_rect, (void *)rect);
+}
+
+void glc_clip_path(GLCCtx glc, GLCPath path, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx && path);
+    clip_common(ctx, op, fill_path, path);
+}
+
+typedef struct FillMaskInfo {
+    int x_dest;
+    int y_dest;
+    int width;
+    int height;
+    int stride;
+    const uint8_t *bitmap;
+} FillMaskInfo;
+
+static void __fill_mask(InternaCtx *ctx, void *data)
+{
+    FillMaskInfo *info = (FillMaskInfo *)data;
+    fill_mask(ctx, info->x_dest, info->y_dest, info->width, info->height, info->stride,
+              info->bitmap);
+}
+
+void glc_clip_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
+                   int stride, const uint8_t *bitmap, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    FillMaskInfo mask_info;
+
+    ASSERT(ctx && bitmap);
+    mask_info.x_dest = x_dest;
+    mask_info.y_dest = y_dest;
+    mask_info.width = width;
+    mask_info.height = height;
+    mask_info.stride = stride;
+    mask_info.bitmap = bitmap;
+    clip_common(ctx, op, __fill_mask, &mask_info);
+}
+
+static inline void start_draw(InternaCtx *ctx)
+{
+    if (ctx->draw_mode) {
+        return;
+    }
+    ctx->draw_mode = TRUE;
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(GL_EQUAL, ctx->stencil_mask, ctx->stencil_mask);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    } else {
+        glDisable(GL_TEXTURE_2D);
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void fill_rect(InternaCtx *ctx, void *r)
+{
+    GLCRect *rect = (GLCRect *)r;
+    glRectd(rect->x, Y(rect->y), rect->x + rect->width, Y(rect->y + rect->height));
+    /*glBegin(GL_POLYGON);
+        VERTEX2(rect->x, rect->y);
+        VERTEX2 (rect->x + rect->width, rect->y);
+        VERTEX2 (rect->x + rect->width, rect->y + rect->height);
+        VERTEX2 (rect->x , rect->y + rect->height);
+    glEnd();*/
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_fill_rect(GLCCtx glc, const GLCRect *rect)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    GLCRect *r = (GLCRect *)rect; // to avoid bugs in gcc older than 4.3
+
+    ASSERT(ctx);
+    start_draw(ctx);
+    fill_rect(ctx, (void *)r);
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void fill_path(InternaCtx *ctx, void *p)
+{
+    InternalPath *path = (InternalPath *)p;
+
+    PathPoint *current_point = path->points;
+    PathSegment *current_segment = path->segments;
+    Path *current_path = path->paths;
+    Path *end_path = current_path + path->paths_pos;
+    reset_tass_vertex(ctx);
+    gluTessBeginPolygon(ctx->tesselator, ctx);
+    for (; current_path < end_path; current_path++) {
+        gluTessBeginContour(ctx->tesselator);
+        PathSegment *end_segment = current_segment + current_path->num_segments;
+        gluTessVertex(ctx->tesselator, (GLdouble *)current_point, current_point);
+        current_point++;
+        for (; current_segment < end_segment; current_segment++) {
+            PathPoint *end_point;
+            if (current_segment->type == GLC_PATH_SEG_BEIZER) {
+                end_point = current_point + current_segment->count * 3;
+                for (; current_point < end_point; current_point += 3) {
+                    TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
+                    while (vertex) {
+                        gluTessVertex(ctx->tesselator, (GLdouble *)&vertex->point,
+                                      (GLdouble *)&vertex->point);
+                        vertex = vertex->list_link;
+                    }
+                    gluTessVertex(ctx->tesselator, (GLdouble *)&current_point[2],
+                                  (GLdouble *)&current_point[2]);
+                }
+            } else {
+                ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
+                end_point = current_point + current_segment->count;
+                for (; current_point < end_point; current_point++) {
+                    gluTessVertex(ctx->tesselator, (GLdouble *)current_point,
+                                  (GLdouble *)current_point);
+                }
+            }
+        }
+        gluTessEndContour(ctx->tesselator);
+    }
+    gluTessEndPolygon(ctx->tesselator);
+}
+
+void glc_fill_path(GLCCtx glc, GLCPath path_ref)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx && path_ref);
+    start_draw(ctx);
+    fill_path(ctx, path_ref);
+}
+
+static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height,
+                      int stride, const uint8_t *bitmap)
+{
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, stride * 8);
+    glBitmap(width, height, 0, 0, 0, 0, bitmap);
+}
+
+void _glc_fill_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                    const uint8_t *bitmap)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx && bitmap);
+    start_draw(ctx);
+    if (ctx->pat) {
+        WARN_ONCE(("%s: unimplemented fill mask with pattern\n", __FUNCTION__));
+    }
+    fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
+}
+
+void glc_fill_alpha(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                    const uint8_t *alpha_mask)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    GLCRect r;
+
+    ASSERT(ctx);
+    start_draw(ctx);
+
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
+    glPixelZoom(1, 1);
+    glDrawPixels(width, height, GL_ALPHA, GL_UNSIGNED_BYTE, alpha_mask);
+
+    r.x = x_dest;
+    r.y = y_dest;
+    r.width = width;
+    r.height = height;
+
+    //todo: support color/texture alpah vals (GL_MODULATE)
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    fill_rect(ctx, &r);
+    glDisable(GL_BLEND);
+}
+
+void glc_stroke_rect(GLCCtx glc, const GLCRect *rect)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+    if (ctx->line_width == 0) {
+        return;
+    }
+
+    start_draw(ctx);
+
+    glBegin(GL_LINES);
+    VERTEX2(rect->x, rect->y + 0.5);
+    VERTEX2(rect->x + rect->width, rect->y + 0.5);
+    VERTEX2(rect->x + rect->width - 0.5, rect->y);
+    VERTEX2(rect->x + rect->width - 0.5, rect->y + rect->height);
+    VERTEX2(rect->x + rect->width, rect->y + rect->height - 0.5);
+    VERTEX2(rect->x, rect->y + rect->height - 0.5);
+    VERTEX2(rect->x + 0.5, rect->y + rect->height);
+    VERTEX2(rect->x + 0.5, rect->y);
+    glEnd();
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void glc_stroke_line(double x1, double y1, double x2, double y2, double width)
+{
+    double ax, ay, bx, by, cx, cy, dx, dy;
+    double norm, tx;
+
+    if (width == 1 || y1 == y2 || x1 == x2) {
+        glBegin(GL_LINES);
+        glVertex2d(x1, y1);
+        glVertex2d(x2, y2);
+        glEnd();
+        return;
+    }
+    norm = (x1 - x2) / (y2 - y1);
+    tx = width / (2 * sqrt(1 + norm * norm));
+    ax = x1 + tx;
+    ay = y1 + norm * (ax - x1);
+    bx = x2 + tx;
+    by = y2 + norm * (bx - x2);
+    cx = x2 - tx;
+    cy = y2 + norm * (cx - x2);
+    dx = x1 - tx;
+    dy = y1 + norm * (dx - x1);
+    glBegin(GL_POLYGON);
+    glVertex2d(ax, ay);
+    glVertex2d(bx, by);
+    glVertex2d(cx, cy);
+    glVertex2d(dx, dy);
+    glEnd();
+}
+
+static double glc_stroke_line_dash(double x1, double y1, double x2, double y2,
+                                   double width, LineDash *dash)
+{
+    double ax, ay, bx, by;
+    double mx, my, len;
+    double dash_len, total = 0;
+
+    len = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
+    if (!dash->dashes || !dash->num_dashes) {
+        glc_stroke_line(x1, y1, x2, y2, width);
+        return len;
+    }
+    mx = (x2 - x1) / len;
+    my = (y2 - y1) / len;
+    ax = x1;
+    ay = y1;
+    while (total < len) {
+        if (dash->cur_dash >= 0) {
+            dash_len = dash->dashes[dash->cur_dash % dash->num_dashes] - dash->dash_pos;
+        } else {
+            dash_len = dash->offset - dash->dash_pos;
+        }
+        total += dash_len;
+        if (total < len) {
+            bx = x1 + mx * total;
+            by = y1 + my * total;
+            dash->dash_pos = 0;
+        } else {
+            bx = x2;
+            by = y2;
+            dash->dash_pos = dash->dashes[dash->cur_dash % dash->num_dashes] - (total - len);
+        }
+        if (dash->cur_dash % 2 == 0) {
+            glc_stroke_line(ax, ay, bx, by, width);
+        }
+        if (dash->dash_pos == 0) {
+            dash->cur_dash = (dash->cur_dash + 1) % (2 * dash->num_dashes);
+        }
+        ax = bx;
+        ay = by;
+    }
+    return len;
+}
+
+static void glc_vertex2d(InternaCtx *ctx, double x, double y)
+{
+    double len;
+    if (ctx->path_stroke.state == GLC_STROKE_ACTIVE) {
+        len = glc_stroke_line_dash(ctx->path_stroke.x, ctx->path_stroke.y, x, y,
+                                   ctx->line_width, &ctx->line_dash);
+        ctx->path_stroke.x = x;
+        ctx->path_stroke.y = y;
+    } else if (ctx->path_stroke.state == GLC_STROKE_FIRST) {
+        ctx->path_stroke.x = x;
+        ctx->path_stroke.y = y;
+        ctx->path_stroke.state = GLC_STROKE_ACTIVE;
+    } else {
+        ASSERT(ctx->path_stroke.state == GLC_STROKE_NONACTIVE);
+        //error
+    }
+}
+
+static void glc_begin_path(InternaCtx *ctx)
+{
+    ctx->path_stroke.state = GLC_STROKE_FIRST;
+    ctx->line_dash.cur_dash = ctx->line_dash.offset ? -1 : 0;
+    ctx->line_dash.dash_pos = 0;
+}
+
+static void glc_end_path(InternaCtx *ctx)
+{
+    ctx->path_stroke.state = GLC_STROKE_NONACTIVE;
+}
+
+void glc_stroke_path(GLCCtx glc, GLCPath path_ref)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPath *path = (InternalPath *)path_ref;
+
+    ASSERT(ctx && path);
+    if (ctx->line_width == 0) {
+        return;
+    }
+    start_draw(ctx);
+
+    reset_tass_vertex(ctx);
+    PathPoint *current_point = path->points;
+    PathSegment *current_segment = path->segments;
+    Path *current_path = path->paths;
+    Path *end_path = current_path + path->paths_pos;
+    for (; current_path < end_path; current_path++) {
+        glc_begin_path(ctx);
+        PathSegment *end_segment = current_segment + current_path->num_segments;
+        glc_vertex2d(ctx, current_point->x, current_point->y);
+        current_point++;
+        for (; current_segment < end_segment; current_segment++) {
+            PathPoint *end_point;
+            if (current_segment->type == GLC_PATH_SEG_BEIZER) {
+                end_point = current_point + current_segment->count * 3;
+                for (; current_point < end_point; current_point += 3) {
+                    TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
+                    while (vertex) {
+                        glc_vertex2d(ctx, vertex->point.x, vertex->point.y);
+                        vertex = vertex->list_link;
+                    }
+                    glc_vertex2d(ctx, current_point[2].x, current_point[2].y);
+                }
+            } else {
+                ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
+                end_point = current_point + current_segment->count;
+                for (; current_point < end_point; current_point++) {
+                    glc_vertex2d(ctx, current_point->x, current_point->y);
+                }
+            }
+        }
+        glc_end_path(ctx);
+    }
+}
+
+void glc_draw_image(GLCCtx glc, const GLCRecti *dest, const GLCRecti *src, const GLCImage *image,
+                    int scale_mode, double alpha)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint8_t *pixels;
+    const int pix_bytes = 4;
+
+    ASSERT(ctx && image);
+    ASSERT(src->width > 0 && src->height > 0);
+
+    ASSERT(image->format == GLC_IMAGE_RGB32 || image->format == GLC_IMAGE_ARGB32); //for now
+    start_draw(ctx);
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    set_raster_pos(ctx, dest->x, dest->y + dest->height);
+
+    if (dest->width == src->width && src->height == dest->height) {
+        glPixelZoom(1, 1);
+    } else {
+        glPixelZoom((float)dest->width / src->width, (float)dest->height / src->height);
+    }
+
+    pixels = image->pixels + src->x * 4 + (image->height - (src->y + src->height)) * image->stride;
+    if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
+        glPixelTransferf(GL_ALPHA_SCALE, (GLfloat)alpha);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_BLEND);
+    }
+    ASSERT(image->stride % pix_bytes == 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
+    glDrawPixels(src->width, src->height, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
+
+    if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
+        glDisable(GL_BLEND);
+    }
+
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    }
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_copy_pixels(GLCCtx glc, int x_dest, int y_dest, int x_src, int y_src, int width,
+                     int height)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    int recreate = 0;
+
+    ASSERT(ctx);
+#ifdef USE_COPY_PIXELS
+    start_draw(ctx);
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelZoom(1, 1);
+    glCopyPixels(x_src, ctx->height - (y_src + height), width, height, GL_COLOR);
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    }
+#else
+    int width2 = gl_get_to_power_two(width);
+    int height2 = gl_get_to_power_two(height);
+
+    start_draw(ctx);
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    if (width2 > ctx->private_tex_width) {
+        ctx->private_tex_width = width2;
+        recreate = 1;
+    }
+    if (height2 > ctx->private_tex_height) {
+        ctx->private_tex_height = height2;
+        recreate = 1;
+    }
+    if (recreate) {
+        glDeleteTextures(1, &ctx->private_tex);
+        glGenTextures(1, &ctx->private_tex);
+        glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+        ctx->private_tex_width = gl_get_to_power_two(width);
+        ctx->private_tex_height = gl_get_to_power_two(height);
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, ctx->private_tex_width,
+                     ctx->private_tex_height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+    }
+    ASSERT(ctx->private_tex);
+    glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
+    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, x_src, ctx->height - (y_src + height),
+                     width2, height2, 0);
+
+    GLfloat s_gen_params[] = { (GLfloat)1.0 / width2, 0, 0, 0 };
+    GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / height2, 0, 0 };
+    glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
+    glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
+
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef((float)-x_dest / width2, (float)-Y(y_dest + height) / height2, 0);
+
+    glRecti(x_dest, Y(y_dest), x_dest + width, Y(y_dest + height));
+    glFlush();
+    if (!ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    } else {
+        set_pat(ctx, ctx->pat);
+    }
+#endif
+    GLC_ERROR_TEST_FLUSH;
+}
+
+void glc_read_pixels(GLCCtx glc, int x, int y, GLCImage *image)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx && image);
+    ASSERT(image->format == GLC_IMAGE_RGB32); //for now
+    ASSERT((image->stride % 4) == 0); //for now
+    glPixelStorei(GL_PACK_ROW_LENGTH, image->stride / 4);
+    glReadPixels(x, ctx->height - (y + image->height), image->width, image->height,
+                 GL_BGRA, GL_UNSIGNED_BYTE, image->pixels);
+}
+
+void glc_clear(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+
+    ASSERT(ctx);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glClear(GL_COLOR_BUFFER_BIT);
+}
+
+void glc_flush(GLCCtx glc)
+{
+    glFlush();
+
+    GLC_ERROR_TEST_FLUSH;
+}
+
+static void tessellation_combine(GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4],
+                                 GLdouble **data_out, void *usr_data)
+{
+    TassVertex *vertex;
+
+    if (!(vertex = alloc_tess_vertex((InternaCtx *)usr_data))) {
+        *data_out = NULL;
+        return;
+    }
+    vertex->point.x = coords[0];
+    vertex->point.y = coords[1];
+    //vertex->point.z = coords[2];
+    *data_out = (GLdouble *)&vertex->point;
+}
+
+static void tessellation_error(GLenum errorCode)
+{
+    printf("%s: %s\n", __FUNCTION__, gluErrorString(errorCode));
+}
+
+#ifdef WIN32
+#define TESS_CALL_BACK_TYPE void(CALLBACK *)()
+#else
+#define TESS_CALL_BACK_TYPE void(*)()
+#endif
+
+static int init(InternaCtx *ctx, int width, int height)
+{
+#ifdef WIN32
+    if (!(ctx->glBlendEquation = (PFNGLBLENDEQUATIONPROC)wglGetProcAddress("glBlendEquation"))) {
+        return FALSE;
+    }
+#endif
+    ctx->width = width;
+    ctx->height = height;
+    ctx->line_width = 1;
+
+    glClearColor(0, 0, 0, 0);
+    glClearStencil(0);
+
+    if (!(ctx->tesselator = gluNewTess())) {
+        return FALSE;
+    }
+
+    glGenTextures(1, &ctx->private_tex);
+    glBindTexture(GL_TEXTURE_2D, ctx->private_tex);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_get_to_power_two(width),
+                 gl_get_to_power_two(height), 0,
+                 GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+    ctx->private_tex_width = gl_get_to_power_two(width);
+    ctx->private_tex_height = gl_get_to_power_two(height);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    glViewport(0, 0, width, height);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0, width, 0, height, -1, 1);
+
+    gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
+    gluTessCallback(ctx->tesselator, GLU_BEGIN, (TESS_CALL_BACK_TYPE)glBegin);
+    gluTessCallback(ctx->tesselator, GLU_VERTEX, (TESS_CALL_BACK_TYPE)glVertex3dv);
+    gluTessCallback(ctx->tesselator, GLU_END, (TESS_CALL_BACK_TYPE)glEnd);
+    gluTessCallback(ctx->tesselator, GLU_TESS_COMBINE_DATA,
+                    (TESS_CALL_BACK_TYPE)tessellation_combine);
+    gluTessCallback(ctx->tesselator, GLU_TESS_ERROR, (TESS_CALL_BACK_TYPE)tessellation_error);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslatef(0, (GLfloat)height, 0);
+
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &ctx->max_texture_size);
+
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelTransferf(GL_ALPHA_BIAS, 0);
+#ifdef WIN32
+    ctx->glBlendEquation(GL_FUNC_ADD);
+#else
+    glBlendEquation(GL_FUNC_ADD);
+#endif
+
+    glStencilMask(0xff);
+    glClear(GL_STENCIL_BUFFER_BIT);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    return TRUE;
+}
+
+GLCCtx glc_create(int width, int height)
+{
+    InternaCtx *ctx;
+
+    ASSERT(sizeof(PathPoint) == sizeof(Vertex));
+
+    if (!(ctx = (InternaCtx *)zmalloc(sizeof(*ctx)))) {
+        return NULL;
+    }
+
+    if (!init(ctx, width, height)) {
+        free(ctx);
+        return NULL;
+    }
+    return ctx;
+}
+
+/*
+ * In glx video mode change the textures will be destroyed, therefore
+ * if we will try to glDeleteTextures() them we might get seagfault.
+ * (this why we use the textures_lost parameter)
+ */
+void glc_destroy(GLCCtx glc, int textures_lost)
+{
+    InternaCtx *ctx;
+
+    if (!(ctx = (InternaCtx *)glc)) {
+        return;
+    }
+
+    if (!textures_lost) {
+        unref_pat(ctx->pat);
+        ctx->pat = NULL;
+        if (ctx->private_tex) {
+            glDeleteTextures(1, &ctx->private_tex);
+        }
+    }
+
+    free_tass_vertex_bufs(ctx);
+    free(ctx->line_dash.dashes);
+    free(ctx);
+    GLC_ERROR_TEST_FINISH;
+}
+
+/*
+    todo:
+        1. test double vs float in gl calls
+        2. int vs flat raster position
+        3. pixels stride vs bytes stride
+        4. improve non power of two.
+                glGetString(GL_EXTENSIONS);
+                ARB_texture_non_power_of_two
+                ARB_texture_rectangle
+                GL_TEXTURE_RECTANGLE_ARB
+        5. scale
+        6. origin
+        7. fonts
+        8. support more image formats
+        9. use GLCImage in mask ops?
+*/
+
diff --git a/common/glc.c.save b/common/glc.c.save
new file mode 100644
index 00000000..19581105
--- /dev/null
+++ b/common/glc.c.save
@@ -0,0 +1,1413 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#ifdef WIN32
+#include "glext.h"
+#include "wglext.h"
+#endif
+
+#include "glc.h"
+
+#define TRUE 1
+#define FALSE 0
+
+#define ASSERT(x) if (!(x)) {printf("%s: assert failed %s\n", __FUNCTION__, #x); for (;;);}
+
+#define GLC_ERROR_TETS {                                                                        \
+    GLenum gl_err;  glFlush();                                                                  \
+    if ((gl_err = glGetError()) != GL_NO_ERROR) {                                               \
+        printf("%s[%d]: opengl error: %s\n",  __FUNCTION__, __LINE__, gluErrorString(gl_err));  \
+        for(;;);                                                                                \
+    }                                                                                           \
+}
+
+#define WARN_ONCE(x) {      \
+    static int warn = TRUE; \
+    if (warn) {             \
+        printf x;           \
+        warn = FALSE;       \
+    }                       \
+}
+
+#define TESS_VERTEX_ALLOC_BUNCH 20
+
+typedef struct InternaCtx InternaCtx;
+typedef struct InternalPat {
+    InternaCtx *owner;
+    int refs;
+    GLuint texture;
+    int x_orign;
+    int y_orign;
+    int width;
+    int height;
+} InternalPat;
+
+typedef struct Pathpath {
+    int start_point;
+    int num_segments;
+} Path;
+
+enum  {
+    GLC_PATH_SEG_LINES,
+    GLC_PATH_SEG_BEIZER,
+};
+
+//todo: flatten cache
+typedef struct PathSegment {
+    int type;
+    int count;
+} PathSegment;
+
+typedef struct PathPoint {
+    double x;
+    double y;
+    double z;
+} PathPoint;
+
+typedef GLdouble Vertex[3];
+
+typedef struct InternalPath {
+    InternaCtx *owner;
+    
+    Path *paths;
+    int paths_size;
+    int paths_pos;
+
+    PathSegment *segments;
+    int segments_size;
+    int segments_pos;
+   
+    PathPoint *points;
+    int points_size;
+    int points_pos;
+    
+    Path *current_path;
+    PathSegment *current_segment;
+    
+} InternalPath;
+
+typedef struct TassVertex TassVertex;
+struct TassVertex {
+    PathPoint point;
+    TassVertex *list_link;
+    TassVertex *next;
+};
+
+typedef struct TassVertexBuf TassVertexBuf;
+struct TassVertexBuf {
+    TassVertexBuf *next;
+    TassVertex vertexs[0];
+};
+
+struct InternaCtx {
+    int draw_mode;
+    int stencil_refs;
+    int stencil_mask;
+    int width;
+    int height;
+    GLfloat line_width;
+    InternalPat *pat;
+    int max_texture_size;
+    GLUtesselator* tesselator;
+    TassVertex *free_tess_vertex;
+    TassVertex *used_tess_vertex;
+    TassVertexBuf *vertex_bufs;
+#ifdef WIN32
+    PFNGLBLENDEQUATIONPROC glBlendEquation;
+#endif
+};
+
+#define Y(y) -(y)
+#define VERTEX2(x, y) glVertex2d(x, Y(y))
+
+static void fill_rect(InternaCtx *ctx, void *rect);
+static void fill_path(InternaCtx *ctx, void *path);
+static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height, int stride,
+                      const uint8_t *bitmap);
+static void set_pat(InternaCtx *ctx, InternalPat *pat);
+
+static inline void *zmalloc(size_t size)
+{
+    return calloc(1, size);
+}
+
+static inline void set_raster_pos(InternaCtx *ctx, int x, int y)
+{
+    if (x >= 0 && y >= 0 && x < ctx->width && y < ctx->height) {
+        glRasterPos2i(x, Y(y));
+        return;
+    }
+    glRasterPos2i(0, 0);
+    glBitmap(0, 0, 0, 0, (GLfloat)x, (GLfloat)Y(y), NULL);
+}
+
+static TassVertex *alloc_tess_vertex(InternaCtx *ctx)
+{
+    TassVertex *vertex;
+    
+    if (!ctx->free_tess_vertex) {
+        TassVertexBuf *buf;
+        int i;
+        
+        if (!(buf = (TassVertexBuf *)malloc(sizeof(TassVertexBuf) +
+                                            sizeof(TassVertex) * TESS_VERTEX_ALLOC_BUNCH))) {
+            //warn
+            return NULL;
+        }
+        buf->next = ctx->vertex_bufs;
+        ctx->vertex_bufs = buf;
+        for (i = 0; i < TESS_VERTEX_ALLOC_BUNCH; i++) {
+            buf->vertexs[i].point.z = 0;
+            buf->vertexs[i].next = ctx->free_tess_vertex;
+            ctx->free_tess_vertex = &buf->vertexs[i];
+        }
+    }
+    
+    vertex = ctx->free_tess_vertex;
+    ctx->free_tess_vertex = vertex->next;
+    vertex->next = ctx->used_tess_vertex;
+    ctx->used_tess_vertex = vertex;
+    return vertex;
+}
+
+static void reset_tass_vertex(InternaCtx *ctx)
+{
+    TassVertex *vertex;
+    while ((vertex = ctx->used_tess_vertex)) {
+        ctx->used_tess_vertex = vertex->next;
+        vertex->next = ctx->free_tess_vertex;
+        ctx->free_tess_vertex = vertex;
+    }
+}
+
+static void free_tass_vertex_bufs(InternaCtx *ctx)
+{
+    TassVertexBuf *buf;
+    
+    ctx->used_tess_vertex = NULL;
+    ctx->free_tess_vertex = NULL;
+    while ((buf = ctx->vertex_bufs)) {
+        ctx->vertex_bufs = buf->next;
+        free(buf);
+    }
+}
+
+//naiev bezier flattener
+static TassVertex *bezier_flattener(InternaCtx *ctx, PathPoint *points)
+{
+    double   ax, bx, cx;
+    double   ay, by, cy;
+    const int num_points = 30;
+    double dt;
+    int i;
+    
+    TassVertex *vertex_list = NULL;
+    TassVertex *curr_vertex;
+    
+    for (i = 0; i < num_points - 2; i++) {
+        TassVertex *vertex;
+        
+        if (!(vertex = alloc_tess_vertex(ctx))) {
+            //warn
+            return NULL;
+        }
+        vertex->list_link = vertex_list;
+        vertex_list = vertex;
+    }
+    
+    curr_vertex = vertex_list;
+ 
+    cx = 3.0 * (points[1].x - points[0].x);
+    bx = 3.0 * (points[2].x - points[1].x) - cx;
+    ax = points[3].x - points[0].x - cx - bx;
+ 
+    cy = 3.0 * (points[1].y - points[0].y);
+    by = 3.0 * (points[2].y - points[1].y) - cy;
+    ay = points[3].y - points[0].y - cy - by;
+ 
+    dt = 1.0 / ( num_points - 1 );
+ 
+    for( i = 1; i < num_points - 1; i++, curr_vertex = curr_vertex->list_link) {
+        double  tSquared, tCubed;
+        double t;
+        t = i * dt;
+        
+        tSquared = t * t;
+        tCubed = tSquared * t;
+ 
+        curr_vertex->point.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + points[0].x;
+        curr_vertex->point.y = (ay * tCubed) + (by * tSquared) + (cy * t) + points[0].y;
+    }
+    
+    return vertex_list;
+}
+
+#define MORE_X(path, Type, name) {\
+    Type *name;\
+    \
+    if (!(name = (Type *)zmalloc(sizeof(*name) * path->name##_size * 2))) {\
+        return FALSE;\
+    }\
+    memcpy(name, path->name, sizeof(*name) * path->name##_size);\
+    free(path->name);\
+    path->name = name;\
+    path->name##_size *= 2;\
+    return TRUE;\
+}
+
+static int more_points(InternalPath *path)
+{
+    MORE_X(path, PathPoint, points);
+}
+
+static int more_segments(InternalPath *path)
+{
+    MORE_X(path, PathSegment, segments);
+}
+
+static int more_paths(InternalPath *path)
+{
+    MORE_X(path, Path, paths);
+}
+
+static inline void put_point(InternalPath *path, double x, double y)
+{
+    path->points[path->points_pos].x = x;
+    path->points[path->points_pos++].y = Y(y + 0.5);
+    path->points[path->points_pos].z = 0;
+}
+
+void glc_path_move_to(GLCPath path, double x, double y)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    ASSERT(internal);
+    
+    if (internal->current_segment) {
+        internal->current_segment = NULL;
+        internal->current_path = NULL;
+        if (internal->points_pos == internal->points_size && !more_points(internal)) {
+            //warn
+            return;
+        }
+        internal->points_pos++;
+    }
+    internal->points[internal->points_pos - 1].x = x;
+    internal->points[internal->points_pos - 1].y = Y(y + 0.5); 
+    internal->points[internal->points_pos - 1].z = 0;
+}
+
+static int add_segment_common(InternalPath *internal, int type, int num_points)
+{
+    if (internal->points_size - internal->points_pos < num_points && !more_points(internal)) {
+        //warn
+        return FALSE;
+    }
+    
+    if (internal->current_segment) {
+        if (internal->current_segment->type == type) {
+            internal->current_segment->count++;
+            return TRUE;
+        }
+        if (internal->segments_pos == internal->segments_size && !more_segments(internal)) {
+            //warn
+            return FALSE;
+        }
+        internal->current_segment = &internal->segments[internal->segments_pos++];
+        internal->current_segment->type = type;
+        internal->current_segment->count = 1;
+        internal->current_path->num_segments++;
+        return TRUE;
+    } 
+    
+    if (internal->paths_pos == internal->paths_size && !more_paths(internal)) {
+        //warn
+        return FALSE;
+    }
+
+    if (internal->segments_pos == internal->segments_size && !more_segments(internal)) {
+        //warn
+        return FALSE;
+    }
+    
+    internal->current_path = &internal->paths[internal->paths_pos++];
+    internal->current_path->start_point = internal->points_pos - 1;
+    internal->current_path->num_segments = 1;
+    internal->current_segment = &internal->segments[internal->segments_pos++];
+    internal->current_segment->type = type;
+    internal->current_segment->count = 1;
+    return TRUE;
+}
+
+void glc_path_line_to(GLCPath path, double x, double y)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    ASSERT(internal);
+    
+    if (!add_segment_common(internal, GLC_PATH_SEG_LINES, 1)) {
+        return;
+    }
+    put_point(internal, x, y);
+}
+
+void glc_path_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
+                       double p3_x, double p3_y)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    ASSERT(internal);
+    
+    if (!add_segment_common(internal, GLC_PATH_SEG_BEIZER, 3)) {
+        return;
+    }   
+    put_point(internal, p1_x, p1_y);
+    put_point(internal, p2_x, p2_y);
+    put_point(internal, p3_x, p3_y);
+}
+
+void glc_path_close(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    ASSERT(internal);
+    if (!internal->current_path) {
+        return;
+    }
+    PathPoint *end_point = &internal->points[internal->current_path->start_point];
+    glc_path_line_to(path, end_point->x, Y(end_point->y));
+    glc_path_move_to(path, end_point->x, Y(end_point->y));
+}
+
+void glc_path_cleare(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    ASSERT(internal);
+    internal->paths_pos = internal->segments_pos = 0;
+    internal->current_segment = NULL;
+    internal->current_path = NULL;
+    
+    internal->points[0].x = 0;
+    internal->points[0].y = 0;
+    internal->points_pos = 1;
+}
+
+GLCPath glc_path_create(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPath *path;
+    
+    ASSERT(ctx);
+    if (!(path = (InternalPath *)zmalloc(sizeof(*path)))) {
+        return NULL;
+    }
+    
+    path->paths = (Path *)malloc(sizeof(*path->paths) * (path->paths_size = 2));
+    if (!path->paths) {
+        goto error_1;
+    }
+    
+    path->segments = (PathSegment *)malloc(sizeof(*path->segments) * (path->segments_size = 4));
+    if (!path->segments) {
+        goto error_2;
+    }
+    
+    path->points = (PathPoint *)malloc(sizeof(*path->points) * (path->points_size = 20));
+    if (!path->points) {
+        goto error_3;
+    }
+    
+    path->owner = ctx;
+    path->points_pos = 1;
+    return path;
+    
+error_3:
+    free(path->segments);
+    
+error_2:
+    free(path->paths);
+        
+error_1:
+    free(path);
+        
+    return NULL;
+}
+
+void glc_path_destroy(GLCPath path)
+{
+    InternalPath *internal = (InternalPath *)path;
+    
+    if (!path) {
+        return;
+    }
+
+    free(internal->points);
+    free(internal->segments);
+    free(internal->paths);
+    free(internal);
+}
+
+static inline void unref_pat(InternalPat *pat)
+{
+    if (!pat) { 
+        return;
+    }
+    ASSERT(pat->refs > 0);
+    if (--pat->refs == 0) {
+        glFinish();
+        glDeleteTextures(1, &pat->texture);
+        free(pat);
+    }
+    GLC_ERROR_TETS;
+}
+
+static inline InternalPat *ref_pat(InternalPat *pat)
+{
+    pat->refs++;
+    return pat;
+}
+
+#ifdef WIN32
+static inline int find_msb(uint32_t val)
+{
+   uint32_t r;
+   __asm {
+        bsr eax, val
+        jnz found
+        mov eax, -1
+        
+    found:
+        mov r, eax
+    }
+    return r + 1;
+}
+#else
+static inline int find_msb(uint32_t val)
+{
+    int ret;
+
+    asm("bsrl %1,%0\n\t"
+        "jnz 1f\n\t"
+        "movl $-1,%0\n"
+        "1:"
+        : "=r"(ret) : "r"(val));
+    return ret + 1;
+}
+#endif
+
+static int to_pwoer_two(uint32_t val)
+{
+    if ((val & (val - 1)) == 0) {
+        return val;
+    }
+    return 1 << find_msb(val);
+}
+
+static void scale(uint32_t *dest, uint32_t dest_width, uint32_t dest_height,
+                  uint32_t *src, uint32_t src_width, uint32_t src_height, int src_stride)
+{
+    double x_scale = (double)src_width / dest_width;
+    double y_scale = (double)src_height / dest_height;
+    uint32_t i;
+    uint32_t j;
+    int prev_row = -1;
+    
+    for (i = 0; i < dest_height; i++) {
+        int row = (int)(y_scale * i);
+        if (row == prev_row) {
+            memcpy(dest, dest - dest_width, dest_width * sizeof(uint32_t));
+            dest += dest_width; 
+            continue;
+        }
+        for (j = 0; j < dest_width; j++) {
+            int col = (int)(x_scale * j);
+            *(dest++) = *(src + col);
+        }
+        prev_row = row;
+        src = (uint32_t *)((uint8_t *)src + src_stride);
+    }
+}
+
+static inline void init_pattern(InternalPat *pat, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternaCtx *ctx = pat->owner;
+    uint32_t *tmp_pixmap = NULL;
+    int width;
+    int height;
+    int width2;
+    int height2;
+
+    const int pix_bytes = 4;
+    
+    ASSERT(image->format == GLC_IMAGE_RGB32); //for now
+
+    width = image->width;
+    height = image->height;
+    width2 = to_pwoer_two(width);
+    height2 = to_pwoer_two(height);
+
+    ASSERT(width > 0 && height > 0);
+    ASSERT(width > 0 &&  width <= pat->owner->max_texture_size);
+    ASSERT(height > 0 && height <= pat->owner->max_texture_size);
+    
+    if (width2 != width || height2 != height) {
+        if (!(tmp_pixmap = (uint32_t *)malloc(width2 * height2 * sizeof(uint32_t)))) {
+            //warn
+            return;
+        }
+        scale(tmp_pixmap, width2, height2, (uint32_t *)image->pixels, width, height, image->stride);
+    }
+    
+    glBindTexture(GL_TEXTURE_2D, pat->texture);
+    
+    //glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+    if (tmp_pixmap) {
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, width2);
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, width2, height2, 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                 tmp_pixmap);
+        free(tmp_pixmap);
+    } else {
+        ASSERT(image->stride % pix_bytes == 0);
+        glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
+        glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE,
+                     image->pixels);
+    }
+    
+    GLC_ERROR_TETS;
+    pat->x_orign = x_orign % width;
+    pat->y_orign = y_orign % height;
+    pat->width = width;
+    pat->height = height;
+    
+    if (ctx->pat == pat) {
+        set_pat(pat->owner, pat);
+    } else if (ctx->pat) {
+        glBindTexture(GL_TEXTURE_2D, ctx->pat->texture);
+    }
+}
+
+GLCPattern glc_pattern_create(GLCCtx glc, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPat *pat;
+    
+    ASSERT(ctx && image);
+    
+    if (!(pat = (InternalPat *)zmalloc(sizeof(*pat)))) {
+        return NULL;
+    }
+    pat->refs = 1;
+    pat->owner = ctx;
+    glGenTextures(1, &pat->texture);
+    init_pattern(pat, x_orign, y_orign, image);
+    return pat;
+}
+
+void glc_pattern_set(GLCPattern pattern, int x_orign, int y_orign, const GLCImage *image)
+{
+    InternalPat *pat = (InternalPat *)pattern;
+    ASSERT(pat && pat->owner);
+
+    glFinish();
+    init_pattern(pat, x_orign, y_orign, image);
+}
+
+void glc_pattern_destroy(GLCPattern pat)
+{
+    unref_pat((InternalPat *)pat);
+    GLC_ERROR_TETS;
+}
+
+static void set_pat(InternaCtx *ctx, InternalPat *pat)
+{
+    pat = ref_pat(pat);
+    unref_pat(ctx->pat);
+    ctx->pat = pat;
+    
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, pat->texture);
+
+    GLfloat s_gen_params[] = { (GLfloat)1.0 / pat->width, 0, 0, 0 }; 
+    GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / (GLfloat)pat->height, 0, 0 };
+    glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
+    glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
+    
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef((float)pat->x_orign / pat->width, (float)Y(pat->y_orign) / pat->height, 0);
+    GLC_ERROR_TETS;
+}
+
+void glc_set_pattern(GLCCtx glc, GLCPattern pattern)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPat *pat = (InternalPat *)pattern;
+
+    ASSERT(ctx && pat && pat->owner == ctx);
+    set_pat(ctx, pat);
+}
+
+void glc_set_rgb(GLCCtx glc, double red, double green, double blue)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    
+    glDisable(GL_TEXTURE_2D);
+    unref_pat(ctx->pat);
+    ctx->pat = NULL;
+    glColor4d(red, green, blue, 1);
+    GLC_ERROR_TETS;
+}
+
+void glc_set_op(GLCCtx glc, GLCOp op)
+{
+    if (op == GL_COPY) {
+        glDisable(GL_COLOR_LOGIC_OP);
+        return;
+    }
+    glLogicOp(op);
+    glEnable(GL_COLOR_LOGIC_OP);
+}
+
+void glc_set_line_width(GLCCtx glc, double width)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    ctx->line_width = (GLfloat)width;
+    if (ctx->line_width > 0) {
+        glLineWidth(ctx->line_width);
+    } else {
+        ctx->line_width = 0;
+    }
+    GLC_ERROR_TETS;
+}
+
+void glc_set_fill_mode(GLCCtx glc, GLCFillMode fill_mode)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    int mode;
+    switch (fill_mode) {
+        case GLC_FILL_MODE_WINDING_ODD:
+            mode = GLU_TESS_WINDING_ODD;
+        break;
+        case GLC_FILL_MODE_WINDING_NONZERO:
+            mode = GLU_TESS_WINDING_NONZERO;
+        break;
+        default:
+            //warn
+            return;
+    }
+    gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, mode);
+}
+
+static inline void add_stencil_client(InternaCtx *ctx)
+{
+    if (!ctx->stencil_refs) {
+        glEnable(GL_STENCIL_TEST);
+    }
+    ctx->stencil_refs++;
+}
+
+static inline void remove_stencil_client(InternaCtx *ctx)
+{
+    ctx->stencil_refs--;
+    if (!ctx->stencil_refs) {
+        glDisable(GL_STENCIL_TEST);
+    }
+}
+
+void glc_set_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
+                  int stride, const uint8_t *bitmap, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    ASSERT(ctx && bitmap);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+    
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    
+    glDisable(GL_BLEND);
+    
+    if (!(ctx->stencil_mask & mask)) {
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= mask;
+    }
+    
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+    glStencilMask(mask);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    
+    glStencilFunc(GL_ALWAYS, mask, mask);
+    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
+}
+
+
+void glc_mask_rects(GLCCtx glc, int num_rect, GLCRect *rects, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    GLCRect *end;
+    ASSERT(ctx && rects);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+    
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    
+    glDisable(GL_BLEND);
+    
+    if (!(ctx->stencil_mask & mask)) {
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= mask;
+    }
+    
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+    glStencilMask(mask);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    
+    glStencilFunc(GL_ALWAYS, mask, mask);
+    glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+    end = rects + num_rect;
+    for (; rects < end; rects++) {
+        fill_rect(ctx, rects);
+    }
+}
+
+void glc_clear_mask(GLCCtx glc, GLCMaskID id)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint32_t mask = (id == GLC_MASK_A) ? 0x04 : 0x08;
+    ASSERT(ctx);
+    ASSERT(id == GLC_MASK_A || id == GLC_MASK_B);
+    
+    if ((ctx->stencil_mask & mask)) {
+        ctx->stencil_mask &= ~mask;
+        remove_stencil_client(ctx);
+    }
+}
+
+void glc_clip_reset(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    if (!(ctx->stencil_mask & 0x03)) {
+        return;
+    }
+    remove_stencil_client(ctx);
+    ctx->stencil_mask &= ~0x03;
+    glStencilMask(0x03);
+    glClear(GL_STENCIL_BUFFER_BIT);
+    GLC_ERROR_TETS;
+}
+
+static void clip_common(InternaCtx *ctx, GLCClipOp op, void (*fill_func)(InternaCtx *, void *),
+                        void *data)
+{
+    int stencil_val;
+    
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    glDisable(GL_BLEND);
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+    ctx->draw_mode = FALSE;
+    
+    if (op == GLC_CLIP_OP_SET) {
+        glc_clip_reset(ctx);
+        add_stencil_client(ctx);
+        ctx->stencil_mask |= 0x01;
+    } else if (!(ctx->stencil_mask & 0x03)) {
+        GLCRect area;
+        if (op == GLC_CLIP_OP_OR) {
+            return;
+        }
+        area.x =  area.y = 0;
+        area.width= ctx->width;
+        area.height = ctx->height;
+        clip_common(ctx, GLC_CLIP_OP_SET, fill_rect, &area);
+    }
+    glStencilMask(0x03);
+    switch (op) {
+        case GLC_CLIP_OP_SET:
+        case GLC_CLIP_OP_OR:
+            stencil_val = ctx->stencil_mask & 0x03;
+            glStencilFunc(GL_ALWAYS, stencil_val, stencil_val);
+            glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+            fill_func(ctx, data);
+            break;
+        case GLC_CLIP_OP_AND: {
+            int clear_mask;
+            stencil_val = ctx->stencil_mask & 0x03;
+            glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
+            if (stencil_val == 0x01) {
+                glStencilOp(GL_ZERO, GL_INCR, GL_INCR);
+                stencil_val = 0x02;
+                clear_mask = 0x01;
+            } else {
+                glStencilOp(GL_ZERO, GL_DECR, GL_DECR);
+                stencil_val = 0x01;
+                clear_mask = 0x02;
+            }
+            fill_func(ctx, data);
+            
+            glStencilMask(clear_mask);
+            glClear(GL_STENCIL_BUFFER_BIT);
+            ctx->stencil_mask = (ctx->stencil_mask & ~clear_mask) |stencil_val; 
+            break;
+        }
+        case GLC_CLIP_OP_EXCLUDE:
+            stencil_val = ctx->stencil_mask & 0x03;
+            glStencilFunc(GL_EQUAL, stencil_val, stencil_val);
+            glStencilOp(GL_KEEP, GL_ZERO, GL_ZERO);
+            fill_func(ctx, data);
+            break;
+    }
+    GLC_ERROR_TETS;
+}
+
+void glc_clip_rect(GLCCtx glc, const GLCRect *rect, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx && rect);
+    clip_common(ctx, op, fill_rect, (void *)rect);
+}
+
+void glc_clip_path(GLCCtx glc, GLCPath path, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx && path);
+    clip_common(ctx, op, fill_path, path);
+}
+
+typedef struct FillMaskInfo {
+    int x_dest;
+    int y_dest;
+    int width;
+    int height;
+    int stride;
+    const uint8_t *bitmap;
+} FillMaskInfo;
+
+static void __fill_mask(InternaCtx *ctx, void *data)
+{
+    FillMaskInfo *info = (FillMaskInfo *)data;
+    fill_mask(ctx, info->x_dest, info->y_dest, info->width, info->height, info->stride,
+              info->bitmap);
+}
+
+void glc_clip_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
+                   int stride, const uint8_t *bitmap, GLCClipOp op)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    FillMaskInfo mask_info;
+
+    ASSERT(ctx && bitmap);
+    mask_info.x_dest = x_dest;
+    mask_info.y_dest = y_dest;
+    mask_info.width = width;
+    mask_info.height = height;
+    mask_info.stride = stride;
+    mask_info.bitmap = bitmap;
+    clip_common(ctx, op, __fill_mask, &mask_info);
+}
+
+static inline void start_draw(InternaCtx *ctx)
+{
+    if (ctx->draw_mode) {
+        return;
+    }
+    ctx->draw_mode = TRUE;
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glStencilFunc(GL_EQUAL, ctx->stencil_mask, ctx->stencil_mask);
+    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    } else {
+        glDisable(GL_TEXTURE_2D);
+    }
+    GLC_ERROR_TETS;
+}
+
+static void fill_rect(InternaCtx *ctx, void *r)
+{
+    GLCRect *rect = (GLCRect *)r;
+    glRectd(rect->x, Y(rect->y), rect->x + rect->width, Y(rect->y + rect->height));
+    /*glBegin(GL_POLYGON);
+        VERTEX2(rect->x, rect->y);
+        VERTEX2 (rect->x + rect->width, rect->y);
+        VERTEX2 (rect->x + rect->width, rect->y + rect->height);
+        VERTEX2 (rect->x , rect->y + rect->height);
+    glEnd();*/
+    GLC_ERROR_TETS;
+}
+
+void glc_fill_rect(GLCCtx glc, const GLCRect *rect)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    start_draw(ctx);
+    fill_rect(ctx, (void *)rect);
+    GLC_ERROR_TETS;
+}
+
+static void fill_path(InternaCtx *ctx, void *p)
+{
+    InternalPath *path = (InternalPath *)p;
+    
+    PathPoint *current_point = path->points;
+    PathSegment *current_segment = path->segments;
+    Path *current_path = path->paths;
+    Path *end_path = current_path + path->paths_pos;
+    reset_tass_vertex(ctx);
+    gluTessBeginPolygon(ctx->tesselator, ctx);
+    for (; current_path < end_path; current_path++) {
+        gluTessBeginContour(ctx->tesselator);
+        PathSegment *end_segment = current_segment + current_path->num_segments;
+        gluTessVertex(ctx->tesselator, (GLdouble *)current_point, current_point);
+        current_point++;
+        for (; current_segment < end_segment; current_segment++) {
+            PathPoint *end_point;
+            if (current_segment->type == GLC_PATH_SEG_BEIZER) {
+                end_point = current_point + current_segment->count * 3;
+                for (; current_point < end_point; current_point += 3) {
+                    TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
+                    while (vertex) {
+                        gluTessVertex(ctx->tesselator, (GLdouble *)&vertex->point,
+                                      (GLdouble *)&vertex->point);
+                        vertex = vertex->list_link;
+                    }
+                    gluTessVertex(ctx->tesselator, (GLdouble *)&current_point[2],
+                                  (GLdouble *)&current_point[2]);
+                }
+            } else {
+                ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
+                end_point = current_point + current_segment->count;
+                for (; current_point < end_point; current_point++) {
+                    gluTessVertex(ctx->tesselator, (GLdouble *)current_point ,
+                                  (GLdouble *)current_point);
+                }
+            }
+        }
+        gluTessEndContour(ctx->tesselator);
+    }
+    gluTessEndPolygon(ctx->tesselator);
+}
+
+void glc_fill_path(GLCCtx glc, GLCPath path_ref)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx && path_ref);
+    start_draw(ctx);
+    fill_path(ctx, path_ref);
+}
+
+static void fill_mask(InternaCtx *ctx, int x_dest, int y_dest, int width, int height,
+                      int stride, const uint8_t *bitmap)
+{
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, stride * 8);
+    glBitmap(width, height, 0, 0, 0, 0, bitmap);
+}
+
+void _glc_fill_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                   const uint8_t *bitmap)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx && bitmap);
+    start_draw(ctx);
+    if (ctx->pat) {
+        WARN_ONCE(("%s: unimplemented fill mask with pattern\n", __FUNCTION__));
+    }
+    fill_mask(ctx, x_dest, y_dest, width, height, stride, bitmap);
+}
+
+void glc_fill_alpha(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                    const uint8_t *alpha_mask)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    GLCRect r;
+    
+    ASSERT(ctx);
+    start_draw(ctx);
+
+    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
+    glPixelZoom(1, 1);
+    glDrawPixels(width, height, GL_ALPHA, GL_UNSIGNED_BYTE, alpha_mask);
+
+    r.x = x_dest;
+    r.y = y_dest;
+    r.width = width;
+    r.height = height;
+
+    //todo: support color/texture alpah vals (GL_MODULATE)
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    fill_rect(ctx, &r);
+    glDisable(GL_BLEND);
+}
+
+void glc_stroke_rect(GLCCtx glc, const GLCRect *rect)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    if (ctx->line_width == 0) {
+        return;
+    }
+    
+    start_draw(ctx);
+    
+    glBegin(GL_LINES);
+        VERTEX2 (rect->x , rect->y + 0.5);
+        VERTEX2 (rect->x + rect->width, rect->y + 0.5);
+    glEnd();
+    
+    glBegin(GL_LINES);
+        VERTEX2 (rect->x + rect->width - 0.5, rect->y);
+        VERTEX2 (rect->x + rect->width - 0.5, rect->y + rect->height);
+    glEnd();
+    
+    glBegin(GL_LINES);
+        VERTEX2 (rect->x + rect->width, rect->y + rect->height - 0.5);
+        VERTEX2 (rect->x, rect->y + rect->height - 0.5);
+    glEnd();
+    
+    glBegin(GL_LINES);
+        VERTEX2(rect->x + 0.5, rect->y + rect->height);
+        VERTEX2(rect->x + 0.5 , rect->y);
+    glEnd();
+    GLC_ERROR_TETS;
+}
+
+void glc_stroke_path(GLCCtx glc, GLCPath path_ref)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    InternalPath *path = (InternalPath *)path_ref;
+    
+    ASSERT(ctx && path);
+    if (ctx->line_width == 0) {
+        return;
+    }
+    start_draw(ctx);
+
+    reset_tass_vertex(ctx);
+    PathPoint *current_point = path->points;
+    PathSegment *current_segment = path->segments;
+    Path *current_path = path->paths;
+    Path *end_path = current_path + path->paths_pos;
+    for (; current_path < end_path; current_path++) {
+        glBegin(GL_LINE_STRIP);
+        PathSegment *end_segment = current_segment + current_path->num_segments;
+        glVertex2d(current_point->x , current_point->y);
+        current_point++;
+        for (; current_segment < end_segment; current_segment++) {
+            PathPoint *end_point;
+            if (current_segment->type == GLC_PATH_SEG_BEIZER) {
+                end_point = current_point + current_segment->count * 3;
+                for (; current_point < end_point; current_point += 3) {
+                    TassVertex *vertex = bezier_flattener(ctx, current_point - 1);
+                    while (vertex) {
+                        glVertex2d(vertex->point.x, vertex->point.y);
+                        vertex = vertex->list_link;
+                    }
+                    glVertex2d(current_point[2].x , current_point[2].y);
+                }
+            } else {
+                ASSERT(current_segment->type == GLC_PATH_SEG_LINES);
+                end_point = current_point + current_segment->count;
+                for (; current_point < end_point; current_point++) {
+                    glVertex2d(current_point->x , current_point->y);
+                }
+            }
+        }
+        glEnd();
+    }
+}
+
+void glc_draw_image(GLCCtx glc, const GLCRecti *dest, const GLCRecti *src, const GLCImage *image,
+                    int scale_mode, double alpha)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    uint8_t *pixels;
+    const int pix_bytes = 4;
+
+    ASSERT(ctx && image);
+    ASSERT(src->width > 0 && src->height > 0);
+
+    ASSERT(image->format == GLC_IMAGE_RGB32 || image->format == GLC_IMAGE_ARGB32); //for now
+    start_draw(ctx);
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    set_raster_pos(ctx, dest->x, dest->y + dest->height);
+
+    if (dest->width == src->width && src->height == dest->height) {
+        glPixelZoom(1, 1);
+    } else {
+        glPixelZoom((float)dest->width / src->width, (float)dest->height / src->height);
+    }
+
+    pixels = image->pixels + src->x * 4 + (image->height - (src->y + src->height)) * image->stride;
+    if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
+        glPixelTransferf(GL_ALPHA_SCALE, (GLfloat)alpha);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_BLEND);
+    }
+    ASSERT(image->stride % pix_bytes == 0);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, image->stride / pix_bytes);
+    glDrawPixels(src->width, src->height, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
+
+    if (image->format == GLC_IMAGE_ARGB32 || alpha != 1) {
+        glDisable(GL_BLEND);
+    }
+
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    }
+    GLC_ERROR_TETS;
+}
+
+void glc_copy_pixels(GLCCtx glc, int x_dest, int y_dest, int x_src, int y_src, int width,
+                     int height)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    ASSERT(ctx);
+#ifdef USE_COPY_PIXELS
+    start_draw(ctx);
+    if (ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    }
+    set_raster_pos(ctx, x_dest, y_dest + height);
+    glPixelZoom(1, 1);
+    glCopyPixels(x_src, ctx->height - (y_src + height), width, height, GL_COLOR);
+    if (ctx->pat) {
+        glEnable(GL_TEXTURE_2D);
+    }
+#else
+    GLuint texture;
+    int width2 = to_pwoer_two(width);
+    int height2 = to_pwoer_two(height);
+    
+    start_draw(ctx);
+    glEnable(GL_TEXTURE_2D);
+    glGenTextures(1, &texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, x_src, ctx->height - (y_src + height),
+                     width2, height2, 0);
+    
+    GLfloat s_gen_params[] = { (GLfloat)1.0 / width2, 0, 0, 0 }; 
+    GLfloat t_gen_params[] = { 0, (GLfloat)1.0 / height2, 0, 0 };
+    glTexGenfv(GL_S, GL_OBJECT_PLANE, s_gen_params);
+    glTexGenfv(GL_T, GL_OBJECT_PLANE, t_gen_params);
+    
+    glMatrixMode(GL_TEXTURE);
+    glLoadIdentity();
+    glTranslatef((float)-x_dest / width2, (float)-Y(y_dest + height) / height2, 0);
+
+    glRecti(x_dest, Y(y_dest), x_dest + width, Y(y_dest + height));
+    glFinish();
+    glDeleteTextures(1, &texture);
+    if (!ctx->pat) {
+        glDisable(GL_TEXTURE_2D);
+    } else {
+        set_pat(ctx, ctx->pat);
+    }
+#endif
+    GLC_ERROR_TETS;
+}
+
+void glc_read_pixels(GLCCtx glc, int x, int y, GLCImage *image)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx && image);
+    ASSERT(image->format == GLC_IMAGE_RGB32); //for now
+    ASSERT((image->stride % 4) == 0); //for now
+    glPixelStorei(GL_PACK_ROW_LENGTH, image->stride / 4);
+    glReadPixels(x, ctx->height - (y + image->height), image->width, image->height,
+                 GL_BGRA, GL_UNSIGNED_BYTE, image->pixels);
+}
+
+void glc_clear(GLCCtx glc)
+{
+    InternaCtx *ctx = (InternaCtx *)glc;
+    
+    ASSERT(ctx);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glClear(GL_COLOR_BUFFER_BIT);
+}
+
+void glc_flush(GLCCtx glc)
+{
+    glFlush();
+    
+    GLC_ERROR_TETS;
+}
+
+static void tessellation_combine(GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4],
+                                 GLdouble **data_out, void *usr_data)
+{
+    TassVertex *vertex;
+    
+    if (!(vertex = alloc_tess_vertex((InternaCtx *)usr_data))) {
+        *data_out = NULL;
+        return;
+    }
+    vertex->point.x = coords[0];
+    vertex->point.y = coords[1];
+    //vertex->point.z = coords[2];
+    *data_out = (GLdouble *)&vertex->point;
+}
+
+static void tessellation_error(GLenum errorCode)
+{
+    printf ("%s: %s\n", __FUNCTION__, gluErrorString(errorCode));
+}
+
+#ifdef WIN32
+#define TESS_CALL_BACK_TYPE void (CALLBACK *)()
+#else
+#define TESS_CALL_BACK_TYPE void (*)()
+#endif
+
+static int init(InternaCtx *ctx, int width, int height)
+{
+#ifdef WIN32
+    if (!(ctx->glBlendEquation = (PFNGLBLENDEQUATIONPROC)wglGetProcAddress("glBlendEquation"))) {
+        return FALSE;
+    }
+#endif
+    ctx->width = width;
+    ctx->height = height;
+    ctx->line_width = 1;
+
+    glClearColor(0, 0, 0, 0);
+    glClearStencil(0);
+    
+    if (!(ctx->tesselator = gluNewTess())) {
+        return FALSE;
+    }
+
+    glViewport(0, 0, width, height);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0, width, 0, height, -1, 1);
+
+    gluTessProperty(ctx->tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
+    gluTessCallback(ctx->tesselator, GLU_BEGIN, (TESS_CALL_BACK_TYPE)glBegin);
+    gluTessCallback(ctx->tesselator, GLU_VERTEX, (TESS_CALL_BACK_TYPE)glVertex3dv);
+    gluTessCallback(ctx->tesselator, GLU_END, (TESS_CALL_BACK_TYPE)glEnd);
+    gluTessCallback(ctx->tesselator, GLU_TESS_COMBINE_DATA, (TESS_CALL_BACK_TYPE)tessellation_combine);
+    gluTessCallback(ctx->tesselator, GLU_TESS_ERROR, (TESS_CALL_BACK_TYPE)tessellation_error);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); 
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+    glEnable(GL_TEXTURE_GEN_S); 
+    glEnable(GL_TEXTURE_GEN_T);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glTranslatef(0, (GLfloat)height, 0);
+
+    glGetIntegerv( GL_MAX_TEXTURE_SIZE, &ctx->max_texture_size);
+
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
+    glPixelTransferf(GL_ALPHA_BIAS, 0);
+#ifdef WIN32
+    ctx->glBlendEquation(GL_FUNC_ADD);
+#else
+    glBlendEquation(GL_FUNC_ADD);
+#endif
+
+    glStencilMask(0xff);
+    glClear(GL_STENCIL_BUFFER_BIT);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    return TRUE;
+}
+
+GLCCtx glc_create(int width, int height)
+{
+    InternaCtx *ctx;
+    
+    ASSERT(sizeof(PathPoint) == sizeof(Vertex));
+    
+    if (!(ctx = (InternaCtx *)zmalloc(sizeof(*ctx)))) {
+        return NULL;
+    }
+    
+    if (!init(ctx, width, height)) {
+        free(ctx);
+        return NULL;
+    }
+    return ctx;
+}
+
+void glc_destroy(GLCCtx glc)
+{
+    InternaCtx *ctx;
+    
+    if (!(ctx = (InternaCtx *)glc)) {
+        return;
+    }
+
+    unref_pat(ctx->pat);
+    free_tass_vertex_bufs(ctx);
+    free(ctx);
+}
+
+/*
+    todo: 
+        1. test double vs float in gl calls
+        2. int vs flat raster position
+        3. pixels stride vs bytes stride
+        4. improve non power of two.
+                glGetString(GL_EXTENSIONS);
+                ARB_texture_non_power_of_two
+                ARB_texture_rectangle
+                GL_TEXTURE_RECTANGLE_ARB
+        5. scale
+        6. origin
+        7. fonts
+        8. support more image formats
+        9. use GLCImage in mask ops?
+*/
+
diff --git a/common/glc.h b/common/glc.h
new file mode 100644
index 00000000..6213c375
--- /dev/null
+++ b/common/glc.h
@@ -0,0 +1,158 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef _H_GL_CANVASE
+#define _H_GL_CANVASE
+
+#include <stdint.h>
+
+typedef void * GLCCtx;
+typedef void * GLCPattern;
+typedef void * GLCPath;
+
+typedef struct GLCRect {
+    double x;
+    double y;
+    double width;
+    double height;
+} GLCRect;
+
+typedef struct GLCRecti {
+    int x;
+    int y;
+    int width;
+    int height;
+} GLCRecti;
+
+typedef enum  {
+    GLC_IMAGE_RGB32,
+    GLC_IMAGE_ARGB32,
+} GLCImageFormat;
+
+typedef struct GLCPImage {
+    GLCImageFormat format;
+    int width;
+    int height;
+    int stride;
+    uint8_t *pixels;
+    uint32_t *pallet;
+} GLCImage;
+
+GLCPattern glc_pattern_create(GLCCtx glc, int x_orign, int y_orign, const GLCImage *image);
+void glc_pattern_set(GLCPattern pattern, int x_orign, int y_orign, const GLCImage *image);
+void glc_pattern_destroy(GLCPattern pattern);
+
+void glc_path_move_to(GLCPath path, double x, double y);
+void glc_path_line_to(GLCPath path, double x, double y);
+void glc_path_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
+                       double p3_x, double p3_y);
+void glc_path_rel_move_to(GLCPath path, double x, double y);
+void glc_path_rel_line_to(GLCPath path, double x, double y);
+void glc_path_rel_curve_to(GLCPath path, double p1_x, double p1_y, double p2_x, double p2_y,
+                           double p3_x, double p3_y);
+void glc_path_close(GLCPath path);
+
+void glc_path_cleare(GLCPath);
+GLCPath glc_path_create(GLCCtx glc);
+void glc_path_destroy(GLCPath path);
+
+void glc_set_rgb(GLCCtx glc, double red, double green, double blue);
+void glc_set_rgba(GLCCtx glc, double red, double green, double blue, double alpha);
+void glc_set_pattern(GLCCtx glc, GLCPattern pattern);
+
+typedef enum  {
+    GLC_OP_CLEAR = 0x1500,
+    GLC_OP_SET = 0x150F,
+    GLC_OP_COPY = 0x1503,
+    GLC_OP_COPY_INVERTED = 0x150C,
+    GLC_OP_NOOP = 0x1505,
+    GLC_OP_INVERT = 0x150A,
+    GLC_OP_AND = 0x1501,
+    GLC_OP_NAND = 0x150E,
+    GLC_OP_OR = 0x1507,
+    GLC_OP_NOR = 0x1508,
+    GLC_OP_XOR = 0x1506,
+    GLC_OP_EQUIV = 0x1509,
+    GLC_OP_AND_REVERSE = 0x1502,
+    GLC_OP_AND_INVERTED = 0x1504,
+    GLC_OP_OR_REVERSE = 0x150B,
+    GLC_OP_OR_INVERTED = 0x150D,
+} GLCOp;
+
+void glc_set_op(GLCCtx glc, GLCOp op);
+void glc_set_alpha_factor(GLCCtx glc, double alpah);
+
+typedef enum  {
+    GLC_FILL_MODE_WINDING_ODD,
+    GLC_FILL_MODE_WINDING_NONZERO,
+} GLCFillMode;
+
+void glc_set_fill_mode(GLCCtx glc, GLCFillMode mode);
+void glc_set_line_width(GLCCtx glc, double width);
+void glc_set_line_end_cap(GLCCtx glc, int style);
+void glc_set_line_join(GLCCtx glc, int style);
+void glc_set_miter_limit(GLCCtx glc, int limit);
+void glc_set_line_dash(GLCCtx glc, const double *dashes, int num_dashes, double offset);
+
+typedef enum  {
+    GLC_MASK_A,
+    GLC_MASK_B,
+} GLCMaskID;
+
+void glc_set_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height,
+                  int stride, const uint8_t *bitmap, GLCMaskID id);
+void glc_mask_rects(GLCCtx glc, int num_rect, GLCRect *rects, GLCMaskID id);
+void glc_clear_mask(GLCCtx glc, GLCMaskID id);
+
+typedef enum {
+    GLC_CLIP_OP_SET,
+    GLC_CLIP_OP_OR,
+    GLC_CLIP_OP_AND,
+    GLC_CLIP_OP_EXCLUDE,
+} GLCClipOp;
+
+void glc_clip_rect(GLCCtx glc, const GLCRect *rect, GLCClipOp op);
+void glc_clip_path(GLCCtx glc, GLCPath path, GLCClipOp op);
+void glc_clip_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                   const uint8_t *bitmap, GLCClipOp op);
+void glc_clip_reset(GLCCtx glc);
+
+void glc_fill_rect(GLCCtx glc, const GLCRect *rect);
+void glc_fill_path(GLCCtx glc, GLCPath path);
+void _glc_fill_mask(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                    const uint8_t *bitmap);
+void glc_fill_alpha(GLCCtx glc, int x_dest, int y_dest, int width, int height, int stride,
+                    const uint8_t *alpha_mask);
+
+void glc_stroke_rect(GLCCtx glc, const GLCRect *rect);
+void glc_stroke_path(GLCCtx glc, GLCPath path);
+
+void glc_draw_image(GLCCtx glc, const GLCRecti *dest, const GLCRecti *src, const GLCImage *image,
+                    int scale_mode, double alpha);
+
+void glc_copy_pixels(GLCCtx glc, int x_dest, int y_dest, int x_src, int y_src, int width,
+                     int height);
+void glc_read_pixels(GLCCtx glc, int x, int y, GLCImage *image);
+
+void glc_flush(GLCCtx glc);
+void glc_clear(GLCCtx glc);
+GLCCtx glc_create(int width, int height);
+void glc_destroy(GLCCtx glc, int textures_lost);
+
+#endif
diff --git a/common/ipc_ring.h b/common/ipc_ring.h
new file mode 100644
index 00000000..1d9b3e1e
--- /dev/null
+++ b/common/ipc_ring.h
@@ -0,0 +1,135 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#ifndef _H_RING_
+#define _H_RING_
+
+
+#define MSB_MASK4(x)        \
+    (((x) & 0x8) ? 0x8 :    \
+     ((x) & 0x4) ? 0x4 :    \
+     ((x) & 0x2) ? 0x2 :    \
+     ((x) & 0x1) ? 0x1 : 0)
+
+#define MSB_MASK8(x) \
+    (((x) & 0xf0) ? MSB_MASK4((x) >> 4) << 4 : MSB_MASK4(x))
+
+#define MSB_MASK16(x) \
+    (((x) & 0xff00) ? MSB_MASK8((x) >> 8) << 8 : MSB_MASK8(x))
+
+#define MSB_MASK(x) \
+    (((x) & 0xffff0000) ? MSB_MASK16((x) >> 16) << 16 : MSB_MASK16(x))
+
+#define POWER2_ALIGN(x) MSB_MASK((x) * 2 - 1)
+
+
+#define _TOSHIFT_4(x)      \
+    (((x) & 0x8) ? 3 :     \
+     ((x) & 0x4) ? 2 :     \
+     ((x) & 0x2) ? 1 : 0)
+
+#define _TOSHIFT_8(x) \
+    (((x) & 0xf0) ? _TOSHIFT_4((x) >> 4) + 4 : _TOSHIFT_4(x))
+
+#define _TOSHIFT_16(x) \
+    (((x) & 0xff00) ? _TOSHIFT_8((x) >> 8) + 8 : _TOSHIFT_8(x))
+
+#define PAWER2_TO_SHIFT(x) \
+    (((x) & 0xffff0000) ? _TOSHIFT_16((x) >> 16) + 16 : _TOSHIFT_16(x))
+
+
+
+#define RING_DECLARE(name, el_type, size)               \
+typedef struct ATTR_PACKED name##_ring_el {             \
+    union {                                             \
+        el_type el;                                     \
+        UINT8 data[POWER2_ALIGN(sizeof(el_type))];      \
+    } ;                                                 \
+} name##_ring_el;                                       \
+                                                        \
+typedef struct ATTR_PACKED name {                       \
+    UINT32 num_items;                                   \
+    UINT32 prod;                                        \
+    UINT32 notify_on_prod;                              \
+    UINT32 cons;                                        \
+    UINT32 notify_on_cons;                              \
+    name##_ring_el items[POWER2_ALIGN(size)];           \
+} name;
+
+
+#define RING_INIT(r)                                                \
+    (r)->num_items = sizeof((r)->items) >>                          \
+                        PAWER2_TO_SHIFT(sizeof((r)->items[0]));     \
+    (r)->prod = (r)->cons = 0;                                      \
+    (r)->notify_on_prod = 1;                                        \
+    (r)->notify_on_cons = 0;
+
+
+#define RING_INDEX_MASK(r) ((r)->num_items - 1)
+
+#define RING_IS_PACKED(r) (sizeof((r)->items[0]) == sizeof((r)->items[0]).el)
+
+#define RING_IS_EMPTY(r) ((r)->cons == (r)->prod)
+
+#define RING_IS_FULL(r) (((r)->prod - (r)->cons) == (r)->num_items)
+
+#define RING_PROD_ITEM(r) (&(r)->items[(r)->prod & RING_INDEX_MASK(r)].el)
+
+#define RING_PROD_WAIT(r, wait)                 \
+    if (((wait) = RING_IS_FULL(r))) {           \
+        (r)->notify_on_cons = (r)->cons + 1;    \
+        mb();	                                \
+        (wait) = RING_IS_FULL(r);               \
+    }
+
+#define RING_PUSH(r, notify)                    \
+    (r)->prod++;                                \
+    mb();                                       \
+    (notify) = (r)->prod == (r)->notify_on_prod;
+
+
+#define RING_CONS_ITEM(r) (&(r)->items[(r)->cons & RING_INDEX_MASK(r)].el)
+
+#define RING_CONS_WAIT(r, wait)                 \
+    if (((wait) = RING_IS_EMPTY(r))) {          \
+        (r)->notify_on_prod = (r)->prod + 1;    \
+        mb();                                   \
+        (wait) = RING_IS_EMPTY(r);              \
+    }
+
+#define RING_POP(r, notify)                         \
+    (r)->cons++;                                    \
+    mb();                                           \
+    (notify) = (r)->cons == (r)->notify_on_cons;
+
+
+
+#endif
diff --git a/common/lookup3.c b/common/lookup3.c
new file mode 100644
index 00000000..f23461ad
--- /dev/null
+++ b/common/lookup3.c
@@ -0,0 +1,769 @@
+/*
+-------------------------------------------------------------------------------
+lookup3.c, by Bob Jenkins, May 2006, Public Domain.
+
+These are functions for producing 32-bit hashes for hash table lookup.
+hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final() 
+are externally useful functions.  Routines to test the hash are included 
+if SELF_TEST is defined.  You can use this free for any purpose.  It's in
+the public domain.  It has no warranty.
+
+You probably want to use hashlittle().  hashlittle() and hashbig()
+hash byte arrays.  hashlittle() is is faster than hashbig() on
+little-endian machines.  Intel and AMD are little-endian machines.
+On second thought, you probably want hashlittle2(), which is identical to
+hashlittle() except it returns two 32-bit hashes for the price of one.  
+You could implement hashbig2() if you wanted but I haven't bothered here.
+
+If you want to find a hash of, say, exactly 7 integers, do
+  a = i1;  b = i2;  c = i3;
+  mix(a,b,c);
+  a += i4; b += i5; c += i6;
+  mix(a,b,c);
+  a += i7;
+  final(a,b,c);
+then use c as the hash value.  If you have a variable length array of
+4-byte integers to hash, use hashword().  If you have a byte array (like
+a character string), use hashlittle().  If you have several byte arrays, or
+a mix of things, see the comments above hashlittle().  
+
+Why is this so big?  I read 12 bytes at a time into 3 4-byte integers, 
+then mix those integers.  This is fast (you can do a lot more thorough
+mixing with 12*3 instructions on 3 integers than you can with 3 instructions
+on 1 byte), but shoehorning those bytes into integers efficiently is messy.
+-------------------------------------------------------------------------------
+*/
+
+#include <stdio.h>      /* defines printf for tests */
+#include <time.h>       /* defines time_t for timings in the test */
+#include "lookup3.h"
+#ifdef linux
+# include <endian.h>    /* attempt to define endianness */
+#endif
+
+/*
+ * My best guess at if you are big-endian or little-endian.  This may
+ * need adjustment.
+ */
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
+     __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(i386) || defined(__i386__) || defined(__i486__) || \
+     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
+# define HASH_LITTLE_ENDIAN 1
+# define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
+       __BYTE_ORDER == __BIG_ENDIAN) || \
+      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 1
+#else
+# define HASH_LITTLE_ENDIAN 0
+# define HASH_BIG_ENDIAN 0
+#endif
+
+#define hashsize(n) ((uint32_t)1<<(n))
+#define hashmask(n) (hashsize(n)-1)
+#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+
+/*
+-------------------------------------------------------------------------------
+mix -- mix 3 32-bit values reversibly.
+
+This is reversible, so any information in (a,b,c) before mix() is
+still in (a,b,c) after mix().
+
+If four pairs of (a,b,c) inputs are run through mix(), or through
+mix() in reverse, there are at least 32 bits of the output that
+are sometimes the same for one pair and different for another pair.
+This was tested for:
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or 
+  all zero plus a counter that starts at zero.
+
+Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
+satisfy this are
+    4  6  8 16 19  4
+    9 15  3 18 27 15
+   14  9  3  7 17  3
+Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
+for "differ" defined as + with a one-bit base and a two-bit delta.  I
+used http://burtleburtle.net/bob/hash/avalanche.html to choose 
+the operations, constants, and arrangements of the variables.
+
+This does not achieve avalanche.  There are input bits of (a,b,c)
+that fail to affect some output bits of (a,b,c), especially of a.  The
+most thoroughly mixed value is c, but it doesn't really even achieve
+avalanche in c.
+
+This allows some parallelism.  Read-after-writes are good at doubling
+the number of bits affected, so the goal of mixing pulls in the opposite
+direction as the goal of parallelism.  I did what I could.  Rotates
+seem to cost as much as shifts on every machine I could lay my hands
+on, and rotates are much kinder to the top and bottom bits, so I used
+rotates.
+-------------------------------------------------------------------------------
+*/
+#define mix(a,b,c) \
+{ \
+  a -= c;  a ^= rot(c, 4);  c += b; \
+  b -= a;  b ^= rot(a, 6);  a += c; \
+  c -= b;  c ^= rot(b, 8);  b += a; \
+  a -= c;  a ^= rot(c,16);  c += b; \
+  b -= a;  b ^= rot(a,19);  a += c; \
+  c -= b;  c ^= rot(b, 4);  b += a; \
+}
+
+/*
+-------------------------------------------------------------------------------
+final -- final mixing of 3 32-bit values (a,b,c) into c
+
+Pairs of (a,b,c) values differing in only a few bits will usually
+produce values of c that look totally different.  This was tested for
+* pairs that differed by one bit, by two bits, in any combination
+  of top bits of (a,b,c), or in any combination of bottom bits of
+  (a,b,c).
+* "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
+  the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+  is commonly produced by subtraction) look like a single 1-bit
+  difference.
+* the base values were pseudorandom, all zero but one bit set, or 
+  all zero plus a counter that starts at zero.
+
+These constants passed:
+ 14 11 25 16 4 14 24
+ 12 14 25 16 4 14 24
+and these came close:
+  4  8 15 26 3 22 24
+ 10  8 15 26 3 22 24
+ 11  8 15 26 3 22 24
+-------------------------------------------------------------------------------
+*/
+#define final(a,b,c) \
+{ \
+  c ^= b; c -= rot(b,14); \
+  a ^= c; a -= rot(c,11); \
+  b ^= a; b -= rot(a,25); \
+  c ^= b; c -= rot(b,16); \
+  a ^= c; a -= rot(c,4);  \
+  b ^= a; b -= rot(a,14); \
+  c ^= b; c -= rot(b,24); \
+}
+
+/*
+--------------------------------------------------------------------
+ This works on all machines.  To be useful, it requires
+ -- that the key be an array of uint32_t's, and
+ -- that the length be the number of uint32_t's in the key
+
+ The function hashword() is identical to hashlittle() on little-endian
+ machines, and identical to hashbig() on big-endian machines,
+ except that the length has to be measured in uint32_ts rather than in
+ bytes.  hashlittle() is more complicated than hashword() only because
+ hashlittle() has to dance around fitting the key bytes into registers.
+--------------------------------------------------------------------
+*/
+uint32_t hashword(
+const uint32_t *k,                   /* the key, an array of uint32_t values */
+size_t          length,               /* the length of the key, in uint32_ts */
+uint32_t        initval)         /* the previous hash, or an arbitrary value */
+{
+  uint32_t a,b,c;
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
+
+  /*------------------------------------------------- handle most of the key */
+  while (length > 3)
+  {
+    a += k[0];
+    b += k[1];
+    c += k[2];
+    mix(a,b,c);
+    length -= 3;
+    k += 3;
+  }
+
+  /*------------------------------------------- handle the last 3 uint32_t's */
+  switch(length)                     /* all the case statements fall through */
+  { 
+  case 3 : c+=k[2];
+  case 2 : b+=k[1];
+  case 1 : a+=k[0];
+    final(a,b,c);
+  case 0:     /* case 0: nothing left to add */
+    break;
+  }
+  /*------------------------------------------------------ report the result */
+  return c;
+}
+
+
+/*
+--------------------------------------------------------------------
+hashword2() -- same as hashword(), but take two seeds and return two
+32-bit values.  pc and pb must both be nonnull, and *pc and *pb must
+both be initialized with seeds.  If you pass in (*pb)==0, the output 
+(*pc) will be the same as the return value from hashword().
+--------------------------------------------------------------------
+*/
+void hashword2 (
+const uint32_t *k,                   /* the key, an array of uint32_t values */
+size_t          length,               /* the length of the key, in uint32_ts */
+uint32_t       *pc,                      /* IN: seed OUT: primary hash value */
+uint32_t       *pb)               /* IN: more seed OUT: secondary hash value */
+{
+  uint32_t a,b,c;
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + *pc;
+  c += *pb;
+
+  /*------------------------------------------------- handle most of the key */
+  while (length > 3)
+  {
+    a += k[0];
+    b += k[1];
+    c += k[2];
+    mix(a,b,c);
+    length -= 3;
+    k += 3;
+  }
+
+  /*------------------------------------------- handle the last 3 uint32_t's */
+  switch(length)                     /* all the case statements fall through */
+  { 
+  case 3 : c+=k[2];
+  case 2 : b+=k[1];
+  case 1 : a+=k[0];
+    final(a,b,c);
+  case 0:     /* case 0: nothing left to add */
+    break;
+  }
+  /*------------------------------------------------------ report the result */
+  *pc=c; *pb=b;
+}
+
+
+/*
+-------------------------------------------------------------------------------
+hashlittle() -- hash a variable-length key into a 32-bit value
+  k       : the key (the unaligned variable-length array of bytes)
+  length  : the length of the key, counting by bytes
+  initval : can be any 4-byte value
+Returns a 32-bit value.  Every bit of the key affects every bit of
+the return value.  Two keys differing by one or two bits will have
+totally different hash values.
+
+The best hash table sizes are powers of 2.  There is no need to do
+mod a prime (mod is sooo slow!).  If you need less than 32 bits,
+use a bitmask.  For example, if you need only 10 bits, do
+  h = (h & hashmask(10));
+In which case, the hash table should have hashsize(10) elements.
+
+If you are hashing n strings (uint8_t **)k, do it like this:
+  for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
+
+By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
+code any way you wish, private, educational, or commercial.  It's free.
+
+Use for hash table lookup, or anything where one collision in 2^^32 is
+acceptable.  Do NOT use for cryptographic purposes.
+-------------------------------------------------------------------------------
+*/
+
+uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+  u.ptr = key;
+  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+#ifdef VALGRIND
+    const uint8_t  *k8;
+#endif
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /* 
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+#ifndef VALGRIND
+
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+    case 9 : c+=k8[8];                   /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+    case 5 : b+=k8[4];                   /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+    case 1 : a+=k8[0]; break;
+    case 0 : return c;
+    }
+
+#endif /* !valgrind */
+
+  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : return c;                     /* zero length requires no mixing */
+    }
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  return c;
+}
+
+
+/*
+ * hashlittle2: return 2 32-bit hash values
+ *
+ * This is identical to hashlittle(), except it returns two 32-bit hash
+ * values instead of just one.  This is good enough for hash table
+ * lookup with 2^^64 buckets, or if you want a second hash if you're not
+ * happy with the first, or if you want a probably-unique 64-bit ID for
+ * the key.  *pc is better mixed than *pb, so use *pc first.  If you want
+ * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)".
+ */
+void hashlittle2( 
+  const void *key,       /* the key to hash */
+  size_t      length,    /* length of the key */
+  uint32_t   *pc,        /* IN: primary initval, OUT: primary hash */
+  uint32_t   *pb)        /* IN: secondary initval, OUT: secondary hash */
+{
+  uint32_t a,b,c;                                          /* internal state */
+  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc;
+  c += *pb;
+
+  u.ptr = key;
+  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+#ifdef VALGRIND
+    const uint8_t  *k8;
+#endif
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /* 
+     * "k[2]&0xffffff" actually reads beyond the end of the string, but
+     * then masks off the part it's not allowed to read.  Because the
+     * string is aligned, the masked-off tail is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+#ifndef VALGRIND
+
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff; break;
+    case 2 : a+=k[0]&0xffff; break;
+    case 1 : a+=k[0]&0xff; break;
+    case 0 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
+    }
+
+#else /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+    case 9 : c+=k8[8];                   /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+    case 5 : b+=k8[4];                   /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+    case 1 : a+=k8[0]; break;
+    case 0 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
+    }
+
+#endif /* !valgrind */
+
+  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
+    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
+    const uint8_t  *k8;
+
+    /*--------------- all but last block: aligned reads and different mixing */
+    while (length > 12)
+    {
+      a += k[0] + (((uint32_t)k[1])<<16);
+      b += k[2] + (((uint32_t)k[3])<<16);
+      c += k[4] + (((uint32_t)k[5])<<16);
+      mix(a,b,c);
+      length -= 12;
+      k += 6;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    k8 = (const uint8_t *)k;
+    switch(length)
+    {
+    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+    case 10: c+=k[4];
+             b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 9 : c+=k8[8];                      /* fall through */
+    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+    case 6 : b+=k[2];
+             a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 5 : b+=k8[4];                      /* fall through */
+    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+             break;
+    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+    case 2 : a+=k[0];
+             break;
+    case 1 : a+=k8[0];
+             break;
+    case 0 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
+    }
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      a += ((uint32_t)k[1])<<8;
+      a += ((uint32_t)k[2])<<16;
+      a += ((uint32_t)k[3])<<24;
+      b += k[4];
+      b += ((uint32_t)k[5])<<8;
+      b += ((uint32_t)k[6])<<16;
+      b += ((uint32_t)k[7])<<24;
+      c += k[8];
+      c += ((uint32_t)k[9])<<8;
+      c += ((uint32_t)k[10])<<16;
+      c += ((uint32_t)k[11])<<24;
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=((uint32_t)k[11])<<24;
+    case 11: c+=((uint32_t)k[10])<<16;
+    case 10: c+=((uint32_t)k[9])<<8;
+    case 9 : c+=k[8];
+    case 8 : b+=((uint32_t)k[7])<<24;
+    case 7 : b+=((uint32_t)k[6])<<16;
+    case 6 : b+=((uint32_t)k[5])<<8;
+    case 5 : b+=k[4];
+    case 4 : a+=((uint32_t)k[3])<<24;
+    case 3 : a+=((uint32_t)k[2])<<16;
+    case 2 : a+=((uint32_t)k[1])<<8;
+    case 1 : a+=k[0];
+             break;
+    case 0 : *pc=c; *pb=b; return;  /* zero length strings require no mixing */
+    }
+  }
+
+  final(a,b,c);
+  *pc=c; *pb=b;
+}
+
+
+
+/*
+ * hashbig():
+ * This is the same as hashword() on big-endian machines.  It is different
+ * from hashlittle() on all machines.  hashbig() takes advantage of
+ * big-endian byte ordering. 
+ */
+uint32_t hashbig( const void *key, size_t length, uint32_t initval)
+{
+  uint32_t a,b,c;
+  union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
+
+  /* Set up the internal state */
+  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+
+  u.ptr = key;
+  if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
+    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+#ifdef VALGRIND
+    const uint8_t  *k8;
+#endif
+
+    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += k[0];
+      b += k[1];
+      c += k[2];
+      mix(a,b,c);
+      length -= 12;
+      k += 3;
+    }
+
+    /*----------------------------- handle the last (probably partial) block */
+    /* 
+     * "k[2]<<8" actually reads beyond the end of the string, but
+     * then shifts out the part it's not allowed to read.  Because the
+     * string is aligned, the illegal read is in the same word as the
+     * rest of the string.  Every machine with memory protection I've seen
+     * does it on word boundaries, so is OK with this.  But VALGRIND will
+     * still catch it and complain.  The masking trick does make the hash
+     * noticably faster for short strings (like English words).
+     */
+#ifndef VALGRIND
+
+    switch(length)
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
+    case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
+    case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
+    case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
+    case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
+    case 4 : a+=k[0]; break;
+    case 3 : a+=k[0]&0xffffff00; break;
+    case 2 : a+=k[0]&0xffff0000; break;
+    case 1 : a+=k[0]&0xff000000; break;
+    case 0 : return c;              /* zero length strings require no mixing */
+    }
+
+#else  /* make valgrind happy */
+
+    k8 = (const uint8_t *)k;
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+    case 11: c+=((uint32_t)k8[10])<<8;  /* fall through */
+    case 10: c+=((uint32_t)k8[9])<<16;  /* fall through */
+    case 9 : c+=((uint32_t)k8[8])<<24;  /* fall through */
+    case 8 : b+=k[1]; a+=k[0]; break;
+    case 7 : b+=((uint32_t)k8[6])<<8;   /* fall through */
+    case 6 : b+=((uint32_t)k8[5])<<16;  /* fall through */
+    case 5 : b+=((uint32_t)k8[4])<<24;  /* fall through */
+    case 4 : a+=k[0]; break;
+    case 3 : a+=((uint32_t)k8[2])<<8;   /* fall through */
+    case 2 : a+=((uint32_t)k8[1])<<16;  /* fall through */
+    case 1 : a+=((uint32_t)k8[0])<<24; break;
+    case 0 : return c;
+    }
+
+#endif /* !VALGRIND */
+
+  } else {                        /* need to read the key one byte at a time */
+    const uint8_t *k = (const uint8_t *)key;
+
+    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+    while (length > 12)
+    {
+      a += ((uint32_t)k[0])<<24;
+      a += ((uint32_t)k[1])<<16;
+      a += ((uint32_t)k[2])<<8;
+      a += ((uint32_t)k[3]);
+      b += ((uint32_t)k[4])<<24;
+      b += ((uint32_t)k[5])<<16;
+      b += ((uint32_t)k[6])<<8;
+      b += ((uint32_t)k[7]);
+      c += ((uint32_t)k[8])<<24;
+      c += ((uint32_t)k[9])<<16;
+      c += ((uint32_t)k[10])<<8;
+      c += ((uint32_t)k[11]);
+      mix(a,b,c);
+      length -= 12;
+      k += 12;
+    }
+
+    /*-------------------------------- last block: affect all 32 bits of (c) */
+    switch(length)                   /* all the case statements fall through */
+    {
+    case 12: c+=k[11];
+    case 11: c+=((uint32_t)k[10])<<8;
+    case 10: c+=((uint32_t)k[9])<<16;
+    case 9 : c+=((uint32_t)k[8])<<24;
+    case 8 : b+=k[7];
+    case 7 : b+=((uint32_t)k[6])<<8;
+    case 6 : b+=((uint32_t)k[5])<<16;
+    case 5 : b+=((uint32_t)k[4])<<24;
+    case 4 : a+=k[3];
+    case 3 : a+=((uint32_t)k[2])<<8;
+    case 2 : a+=((uint32_t)k[1])<<16;
+    case 1 : a+=((uint32_t)k[0])<<24;
+             break;
+    case 0 : return c;
+    }
+  }
+
+  final(a,b,c);
+  return c;
+}
+
diff --git a/common/lookup3.h b/common/lookup3.h
new file mode 100644
index 00000000..a2fbdeab
--- /dev/null
+++ b/common/lookup3.h
@@ -0,0 +1,43 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __LOOKUP3_H
+#define __LOOKUP3_H
+
+#ifdef __GNUC__
+
+#include <stdint.h>
+
+#else
+
+#ifdef QXLDD
+#include <windef.h>
+#include "os_dep.h"
+#else
+#include <stddef.h>
+#include <basetsd.h>
+#endif
+
+typedef UINT32 uint32_t;
+typedef UINT16 uint16_t;
+typedef UINT8 uint8_t;
+
+#endif
+
+uint32_t hashlittle(const void *key, size_t length, uint32_t initval);
+
+#endif
diff --git a/common/lz.c b/common/lz.c
new file mode 100644
index 00000000..eac44af6
--- /dev/null
+++ b/common/lz.c
@@ -0,0 +1,720 @@
+/*
+
+ Copyright 2009 Red Hat, Inc. and/or its affiliates.
+
+ This program is licensed to you under the GNU General Public License,
+ version 2 or (at your option) any later version published by the Free
+ Software Foundation.  See the file COPYING for details.
+
+ There is NO WARRANTY for this software, not even the implied
+ warranties of MERCHANTABILITY, NONINFRINGEMENT, or FITNESS FOR A
+ PARTICULAR PURPOSE.
+
+ This file incorporates work covered by the following copyright and
+ permission notice:
+   Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the "Software"), to deal in the Software without
+   restriction, including without limitation the rights to use, copy,
+   modify, merge, publish, distribute, sublicense, and/or sell copies
+   of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+*/
+
+#include "lz.h"
+
+#define DEBUG
+
+#ifdef DEBUG
+
+#define ASSERT(usr, x) \
+    if (!(x)) (usr)->error(usr, "%s: ASSERT %s failed\n", __FUNCTION__, #x);
+
+#else
+
+#define ASSERT(usr, x)
+
+#endif
+
+#define HASH_LOG 13
+#define HASH_SIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_SIZE - 1)
+
+
+typedef struct LzImageSegment LzImageSegment;
+struct LzImageSegment {
+    uint8_t            *lines;
+    uint8_t            *lines_end;
+    unsigned int size_delta;    // total size of the previous segments in units of
+                                // pixels for rgb and bytes for plt.
+    LzImageSegment    *next;
+};
+
+//    TODO: pack?
+typedef struct HashEntry {
+    LzImageSegment    *image_seg;
+    uint8_t            *ref;
+} HashEntry;
+
+typedef struct Encoder {
+    LzUsrContext    *usr;
+
+    LzImageType type;
+    const Palette    *palette;    // for decoding images with palettes to rgb
+    int stride;                       // stride is in bytes. For rgb must be equal to
+                                      // width*bytes_per_pix.
+    // For palettes stride can be bigger than width/pixels_per_byte by 1 only if
+    // width%pixels_per_byte != 0.
+    int height;
+    int width;                       // the original width (in pixels)
+
+    LzImageSegment *head_image_segs;
+    LzImageSegment *tail_image_segs;
+    LzImageSegment *free_image_segs;
+
+    // the dicitionary hash table is composed (1) a pointer to the segment the word was found in
+    // (2) a pointer to the first byte in the segment that matches the word
+    HashEntry htab[HASH_SIZE];
+
+    uint8_t            *io_start;
+    uint8_t            *io_now;
+    uint8_t            *io_end;
+    size_t io_bytes_count;
+
+    uint8_t            *io_last_copy;  // pointer to the last byte in which copy count was written
+} Encoder;
+
+/****************************************************/
+/* functions for managing the pool of image segments*/
+/****************************************************/
+static INLINE LzImageSegment *lz_alloc_image_seg(Encoder *encoder);
+static void lz_reset_image_seg(Encoder *encoder);
+static int lz_read_image_segments(Encoder *encoder, uint8_t *first_lines,
+                                  unsigned int num_first_lines);
+
+
+// return a free image segement if one exists. Make allocation if needed. adds it to the
+// tail of the image segments lists
+static INLINE LzImageSegment *lz_alloc_image_seg(Encoder *encoder)
+{
+    LzImageSegment *ret;
+
+    if (encoder->free_image_segs) {
+        ret = encoder->free_image_segs;
+        encoder->free_image_segs = ret->next;
+    } else {
+        if (!(ret = (LzImageSegment *)encoder->usr->malloc(encoder->usr, sizeof(*ret)))) {
+            return NULL;
+        }
+    }
+
+    ret->next = NULL;
+    if (encoder->tail_image_segs) {
+        encoder->tail_image_segs->next = ret;
+    }
+    encoder->tail_image_segs = ret;
+
+    if (!encoder->head_image_segs) {
+        encoder->head_image_segs = ret;
+    }
+
+    return ret;
+}
+
+// adding seg to the head of free segments (lz_reset_image_seg removes it from used ones)
+static INLINE void __lz_free_image_seg(Encoder *encoder, LzImageSegment *seg)
+{
+    seg->next = encoder->free_image_segs;
+    encoder->free_image_segs = seg;
+}
+
+// moves all the used image segments to the free pool
+static void lz_reset_image_seg(Encoder *encoder)
+{
+    while (encoder->head_image_segs) {
+        LzImageSegment *seg = encoder->head_image_segs;
+        encoder->head_image_segs = seg->next;
+        __lz_free_image_seg(encoder, seg);
+    }
+    encoder->tail_image_segs = NULL;
+}
+
+static void lz_dealloc_free_segments(Encoder *encoder)
+{
+    while (encoder->free_image_segs) {
+        LzImageSegment *seg = encoder->free_image_segs;
+        encoder->free_image_segs = seg->next;
+        encoder->usr->free(encoder->usr, seg);
+    }
+}
+
+// return FALSE when operation fails (due to failure in allocation)
+static int lz_read_image_segments(Encoder *encoder, uint8_t *first_lines,
+                                  unsigned int num_first_lines)
+{
+    LzImageSegment *image_seg;
+    uint32_t size_delta = 0;
+    unsigned int num_lines = num_first_lines;
+    uint8_t* lines = first_lines;
+    int row;
+
+    ASSERT(encoder->usr, !encoder->head_image_segs);
+
+    image_seg = lz_alloc_image_seg(encoder);
+    if (!image_seg) {
+        goto error_1;
+    }
+
+    image_seg->lines = lines;
+    image_seg->lines_end = lines + num_lines * encoder->stride;
+    image_seg->size_delta = size_delta;
+
+    size_delta += num_lines * encoder->stride / RGB_BYTES_PER_PIXEL[encoder->type];
+
+    for (row = num_first_lines; row < encoder->height; row += num_lines) {
+        num_lines = encoder->usr->more_lines(encoder->usr, &lines);
+        if (num_lines <= 0) {
+            encoder->usr->error(encoder->usr, "more lines failed\n");
+        }
+        image_seg = lz_alloc_image_seg(encoder);
+
+        if (!image_seg) {
+            goto error_1;
+        }
+
+        image_seg->lines = lines;
+        image_seg->lines_end = lines + num_lines * encoder->stride;
+        image_seg->size_delta = size_delta;
+
+        size_delta += num_lines * encoder->stride / RGB_BYTES_PER_PIXEL[encoder->type];
+    }
+
+    return TRUE;
+error_1:
+    lz_reset_image_seg(encoder);
+    return FALSE;
+}
+
+/**************************************************************************
+* Handling encoding and decoding of a byte
+***************************************************************************/
+static INLINE int more_io_bytes(Encoder *encoder)
+{
+    uint8_t *io_ptr;
+    int num_io_bytes = encoder->usr->more_space(encoder->usr, &io_ptr);
+    encoder->io_bytes_count += num_io_bytes;
+    encoder->io_now = io_ptr;
+    encoder->io_end = encoder->io_now + num_io_bytes;
+    return num_io_bytes;
+}
+
+static INLINE void encode(Encoder *encoder, uint8_t byte)
+{
+    if (encoder->io_now == encoder->io_end) {
+        if (more_io_bytes(encoder) <= 0) {
+            encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
+        }
+        ASSERT(encoder->usr, encoder->io_now);
+    }
+
+    ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
+    *(encoder->io_now++) = byte;
+}
+
+static INLINE void encode_32(Encoder *encoder, unsigned int word)
+{
+    encode(encoder, (uint8_t)(word >> 24));
+    encode(encoder, (uint8_t)(word >> 16) & 0x0000ff);
+    encode(encoder, (uint8_t)(word >> 8) & 0x0000ff);
+    encode(encoder, (uint8_t)(word & 0x0000ff));
+}
+
+static INLINE void encode_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+    encode(encoder, copy_count);
+    encoder->io_last_copy = encoder->io_now - 1; // io_now cannot be the first byte of the buffer
+}
+
+static INLINE void update_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+    ASSERT(encoder->usr, encoder->io_last_copy);
+    *(encoder->io_last_copy) = copy_count;
+}
+
+static INLINE void encode_level(Encoder *encoder, uint8_t level_code)
+{
+    *(encoder->io_start) |= level_code;
+}
+
+// decrease the io ptr by 1
+static INLINE void compress_output_prev(Encoder *encoder)
+{
+    // io_now cannot be the first byte of the buffer
+    encoder->io_now--;
+    // the function should be called only when copy count is written unnecessarily by lz_compress
+    ASSERT(encoder->usr, encoder->io_now == encoder->io_last_copy)
+}
+
+static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
+{
+    ASSERT(encoder->usr, io_ptr <= io_ptr_end);
+    encoder->io_bytes_count = io_ptr_end - io_ptr;
+    encoder->io_start = io_ptr;
+    encoder->io_now = io_ptr;
+    encoder->io_end = io_ptr_end;
+    encoder->io_last_copy = NULL;
+
+    return TRUE;
+}
+
+static INLINE uint8_t decode(Encoder *encoder)
+{
+    if (encoder->io_now == encoder->io_end) {
+        int num_io_bytes = more_io_bytes(encoder);
+        if (num_io_bytes <= 0) {
+            encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
+        }
+        ASSERT(encoder->usr, encoder->io_now);
+    }
+    ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
+    return *(encoder->io_now++);
+}
+
+static INLINE uint32_t decode_32(Encoder *encoder)
+{
+    uint32_t word = 0;
+    word |= decode(encoder);
+    word <<= 8;
+    word |= decode(encoder);
+    word <<= 8;
+    word |= decode(encoder);
+    word <<= 8;
+    word |= decode(encoder);
+    return word;
+}
+
+static INLINE int is_io_to_decode_end(Encoder *encoder)
+{
+    if (encoder->io_now != encoder->io_end) {
+        return FALSE;
+    } else {
+        int num_io_bytes = more_io_bytes(encoder); //disable inline optimizations
+        return (num_io_bytes <= 0);
+    }
+}
+
+/*******************************************************************
+* intialization and finalization of lz
+********************************************************************/
+static int init_encoder(Encoder *encoder, LzUsrContext *usr)
+{
+    encoder->usr = usr;
+    encoder->free_image_segs = NULL;
+    encoder->head_image_segs = NULL;
+    encoder->tail_image_segs = NULL;
+    return TRUE;
+}
+
+LzContext *lz_create(LzUsrContext *usr)
+{
+    Encoder *encoder;
+
+    if (!usr || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
+        !usr->free || !usr->more_space || !usr->more_lines) {
+        return NULL;
+    }
+
+    if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
+        return NULL;
+    }
+
+    if (!init_encoder(encoder, usr)) {
+        usr->free(usr, encoder);
+        return NULL;
+    }
+    return (LzContext *)encoder;
+}
+
+void lz_destroy(LzContext *lz)
+{
+    Encoder *encoder = (Encoder *)lz;
+
+    if (!lz) {
+        return;
+    }
+
+    if (encoder->head_image_segs) {
+        encoder->usr->error(encoder->usr, "%s: used_image_segements not empty\n", __FUNCTION__);
+        lz_reset_image_seg(encoder);
+    }
+    lz_dealloc_free_segments(encoder);
+
+    encoder->usr->free(encoder->usr, encoder);
+}
+
+/*******************************************************************
+*                encoding and decoding the image
+********************************************************************/
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
+#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
+#else
+#define LZ_EXPECT_CONDITIONAL(c) (c)
+#define LZ_UNEXPECT_CONDITIONAL(c) (c)
+#endif
+
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#define ATTR_PACKED
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+
+/* the palette images will be treated as one byte pixels. Their width should be transformed
+   accordingly.
+*/
+typedef struct ATTR_PACKED one_byte_pixel_t {
+    uint8_t a;
+} one_byte_pixel_t;
+
+typedef struct ATTR_PACKED rgb32_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t pad;
+} rgb32_pixel_t;
+
+typedef struct ATTR_PACKED rgb24_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+
+#define MAX_COPY 32
+#define MAX_LEN 264          /* 256 + 8 */
+#define BOUND_OFFSET 2
+#define LIMIT_OFFSET 6
+#define MIN_FILE_SIZE 4
+#define COMP_LEVEL_SIZE_LIMIT 65536
+
+// TODO: implemented lz2. should lz1 be an option (no RLE + distance limitation of MAX_DISTANCE)
+// TODO: I think MAX_FARDISTANCE can be changed easily to 2^29 
+//       (and maybe even more when pixel > byte).
+// i.e. we can support 512M Bytes/Pixels distance instead of only ~68K.
+#define MAX_DISTANCE 8191                        // 2^13
+#define MAX_FARDISTANCE (65535 + MAX_DISTANCE - 1)    // ~2^16+2^13
+
+
+#define LZ_PLT
+#include "lz_compress_tmpl.c"
+#define LZ_PLT
+#include "lz_decompress_tmpl.c"
+
+#define LZ_PLT
+#define PLT8
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_PLT
+#define PLT4_BE
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_PLT
+#define PLT4_LE
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_PLT
+#define PLT1_BE
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_PLT
+#define PLT1_LE
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+
+#define LZ_RGB16
+#include "lz_compress_tmpl.c"
+#define LZ_RGB16
+#include "lz_decompress_tmpl.c"
+#define LZ_RGB16
+#define TO_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_RGB24
+#include "lz_compress_tmpl.c"
+#define LZ_RGB24
+#include "lz_decompress_tmpl.c"
+
+
+#define LZ_RGB32
+#include "lz_compress_tmpl.c"
+#define LZ_RGB32
+#include "lz_decompress_tmpl.c"
+
+#define LZ_RGB_ALPHA
+#include "lz_compress_tmpl.c"
+#define LZ_RGB_ALPHA
+#include "lz_decompress_tmpl.c"
+
+#undef LZ_UNEXPECT_CONDITIONAL
+#undef LZ_EXPECT_CONDITIONAL
+
+int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_down,
+              uint8_t *lines, unsigned int num_lines, int stride,
+              uint8_t *io_ptr, unsigned int num_io_bytes)
+{
+    Encoder *encoder = (Encoder *)lz;
+    uint8_t *io_ptr_end = io_ptr + num_io_bytes;
+
+    encoder->type = type;
+    encoder->width = width;
+    encoder->height = height;
+    encoder->stride = stride;
+
+    if (IS_IMAGE_TYPE_PLT[encoder->type]) {
+        if (encoder->stride > (width / PLT_PIXELS_PER_BYTE[encoder->type])) {
+            if (((width % PLT_PIXELS_PER_BYTE[encoder->type]) == 0) || (
+                    (encoder->stride - (width / PLT_PIXELS_PER_BYTE[encoder->type])) > 1)) {
+                encoder->usr->error(encoder->usr, "sride overflows (plt)\n");
+            }
+        }
+    } else {
+        if (encoder->stride != width * RGB_BYTES_PER_PIXEL[encoder->type]) {
+            encoder->usr->error(encoder->usr, "sride != width*bytes_per_pixel (rgb)\n");
+        }
+    }
+
+    // assign the output buffer
+    if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
+        encoder->usr->error(encoder->usr, "lz encoder io reset failed\n");
+    }
+
+    // first read the list of the image segments
+    if (!lz_read_image_segments(encoder, lines, num_lines)) {
+        encoder->usr->error(encoder->usr, "lz encoder reading image segments failed\n");
+    }
+
+    encode_32(encoder, LZ_MAGIC);
+    encode_32(encoder, LZ_VERSION);
+    encode_32(encoder, type);
+    encode_32(encoder, width);
+    encode_32(encoder, height);
+    encode_32(encoder, stride);
+    encode_32(encoder, top_down); // TODO: maybe compress type and top_down to one byte
+
+    switch (encoder->type) {
+    case LZ_IMAGE_TYPE_PLT1_BE:
+    case LZ_IMAGE_TYPE_PLT1_LE:
+    case LZ_IMAGE_TYPE_PLT4_BE:
+    case LZ_IMAGE_TYPE_PLT4_LE:
+    case LZ_IMAGE_TYPE_PLT8:
+        lz_plt_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB16:
+        lz_rgb16_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB24:
+        lz_rgb24_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB32:
+        lz_rgb32_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGBA:
+        lz_rgb32_compress(encoder);
+        lz_rgb_alpha_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_INVALID:
+    default:
+        encoder->usr->error(encoder->usr, "bad image type\n");
+    }
+
+    // move all the used segments to the free ones
+    lz_reset_image_seg(encoder);
+
+    encoder->io_bytes_count -= (encoder->io_end - encoder->io_now);
+
+    return encoder->io_bytes_count;
+}
+
+/*
+    initialize and read lz magic
+*/
+void lz_decode_begin(LzContext *lz, uint8_t *io_ptr, unsigned int num_io_bytes,
+                     LzImageType *out_type, int *out_width, int *out_height,
+                     int *out_n_pixels, int *out_top_down, const Palette *palette)
+{
+    Encoder *encoder = (Encoder *)lz;
+    uint8_t *io_ptr_end = io_ptr + num_io_bytes;
+    uint32_t magic;
+    uint32_t version;
+
+    if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
+        encoder->usr->error(encoder->usr, "io reset failed");
+    }
+
+    magic = decode_32(encoder);
+    if (magic != LZ_MAGIC) {
+        encoder->usr->error(encoder->usr, "bad magic\n");
+    }
+
+    version = decode_32(encoder);
+    if (version != LZ_VERSION) {
+        encoder->usr->error(encoder->usr, "bad version\n");
+    }
+
+    encoder->type = (LzImageType)decode_32(encoder);
+    encoder->width = decode_32(encoder);
+    encoder->height = decode_32(encoder);
+    encoder->stride = decode_32(encoder);
+    *out_top_down = decode_32(encoder);
+
+    *out_width = encoder->width;
+    *out_height = encoder->height;
+//    *out_stride = encoder->stride;
+    *out_type = encoder->type;
+
+    // TODO: maybe instead of stride we can encode out_n_pixels
+    //       (if stride is not necssary in decoding).
+    if (IS_IMAGE_TYPE_PLT[encoder->type]) {
+        encoder->palette = palette;
+        *out_n_pixels = encoder->stride * PLT_PIXELS_PER_BYTE[encoder->type] * encoder->height;
+    } else {
+        *out_n_pixels = encoder->width * encoder->height;
+    }
+}
+
+void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf)
+{
+    Encoder *encoder = (Encoder *)lz;
+    size_t out_size = 0;
+    size_t alpha_size = 0;
+    int size = 0;
+    if (IS_IMAGE_TYPE_PLT[encoder->type]) {
+        if (to_type == encoder->type) {
+            size = encoder->height * encoder->stride;
+            out_size = lz_plt_decompress(encoder, (one_byte_pixel_t *)buf, size);
+        } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
+            size = encoder->height * encoder->stride * PLT_PIXELS_PER_BYTE[encoder->type];
+            if (!encoder->palette) {
+                encoder->usr->error(encoder->usr,
+                                    "a palette is missing (for bpp to rgb decoding)\n");
+            }
+            switch (encoder->type) {
+            case LZ_IMAGE_TYPE_PLT1_BE:
+                out_size = lz_plt1_be_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                break;
+            case LZ_IMAGE_TYPE_PLT1_LE:
+                out_size = lz_plt1_le_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                break;
+            case LZ_IMAGE_TYPE_PLT4_BE:
+                out_size = lz_plt4_be_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                break;
+            case LZ_IMAGE_TYPE_PLT4_LE:
+                out_size = lz_plt4_le_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                break;
+            case LZ_IMAGE_TYPE_PLT8:
+                out_size = lz_plt8_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                break;
+            case LZ_IMAGE_TYPE_RGB16:
+            case LZ_IMAGE_TYPE_RGB24:
+            case LZ_IMAGE_TYPE_RGB32:
+            case LZ_IMAGE_TYPE_RGBA:
+            case LZ_IMAGE_TYPE_INVALID:
+            default:
+                encoder->usr->error(encoder->usr, "bad image type\n");
+            }
+        } else {
+            encoder->usr->error(encoder->usr, "unsupported output format\n");
+        }
+    } else {
+        size = encoder->height * encoder->width;
+        switch (encoder->type) {
+        case LZ_IMAGE_TYPE_RGB16:
+            if (encoder->type == to_type) {
+                out_size = lz_rgb16_decompress(encoder, (rgb16_pixel_t *)buf, size);
+            } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
+                out_size = lz_rgb16_to_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+            } else {
+                encoder->usr->error(encoder->usr, "unsupported output format\n");
+            }
+            break;
+        case LZ_IMAGE_TYPE_RGB24:
+            if (encoder->type == to_type) {
+                out_size = lz_rgb24_decompress(encoder, (rgb24_pixel_t *)buf, size);
+            } else if (to_type == LZ_IMAGE_TYPE_RGB32) {
+                out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+            } else {
+                encoder->usr->error(encoder->usr, "unsupported output format\n");
+            }
+            break;
+        case LZ_IMAGE_TYPE_RGB32:
+            if (encoder->type == to_type) {
+                out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+            } else {
+                encoder->usr->error(encoder->usr, "unsupported output format\n");
+            }
+            break;
+        case LZ_IMAGE_TYPE_RGBA:
+            if (encoder->type == to_type) {
+                out_size = lz_rgb32_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                alpha_size = lz_rgb_alpha_decompress(encoder, (rgb32_pixel_t *)buf, size);
+                ASSERT(encoder->usr, alpha_size == size);
+            } else {
+                encoder->usr->error(encoder->usr, "unsupported output format\n");
+            }
+            break;
+        case LZ_IMAGE_TYPE_PLT1_LE:
+        case LZ_IMAGE_TYPE_PLT1_BE:
+        case LZ_IMAGE_TYPE_PLT4_LE:
+        case LZ_IMAGE_TYPE_PLT4_BE:
+        case LZ_IMAGE_TYPE_PLT8:
+        case LZ_IMAGE_TYPE_INVALID:
+        default:
+            encoder->usr->error(encoder->usr, "bad image type\n");
+        }
+    }
+
+    ASSERT(encoder->usr, is_io_to_decode_end(encoder));
+    ASSERT(encoder->usr, out_size == size);
+
+    if (out_size != size) {
+        encoder->usr->error(encoder->usr, "bad decode size\n");
+    }
+}
+
diff --git a/common/lz.h b/common/lz.h
new file mode 100644
index 00000000..074f633b
--- /dev/null
+++ b/common/lz.h
@@ -0,0 +1,75 @@
+/*
+        dictionary compression for images based on fastlz (http://www.fastlz.org/)
+        (Distributed under MIT license).
+*/
+#ifndef __LZ_H
+#define __LZ_H
+
+#include "lz_common.h"
+#include "lz_config.h"
+#include "draw.h"
+
+typedef void *LzContext;
+
+typedef struct LzUsrContext LzUsrContext;
+struct LzUsrContext {
+    void (*error)(LzUsrContext *usr, const char *fmt, ...);
+    void (*warn)(LzUsrContext *usr, const char *fmt, ...);
+    void (*info)(LzUsrContext *usr, const char *fmt, ...);
+    void    *(*malloc)(LzUsrContext *usr, int size);
+    void (*free)(LzUsrContext *usr, void *ptr);
+    int (*more_space)(LzUsrContext *usr, uint8_t **io_ptr);     // get the next chunk of the
+                                                                // compressed buffer. return
+                                                                // number of bytes in the chunk.
+    int (*more_lines)(LzUsrContext *usr, uint8_t **lines);      // get the next chunk of the
+                                                                // original image. If the image
+                                                                // is down to top, return it from
+                                                                // the last line to the first one
+                                                                // (stride should always be
+                                                                // positive)
+};
+
+/*
+        assumes width is in pixels and stride is in bytes
+        return: the number of bytes in the compressed data
+
+        TODO :	determine size limit for the first segment and each chunk. check validity
+                        of the segment or go to literal copy.
+        TODO :	currently support only rgb images in which width*bytes_per_pixel = stride OR
+                        paletter images in which stride eqauls the min number of bytes to
+                        hold a line. stride is not necessary for now. just for sanity check.
+                        stride should be > 0
+*/
+int lz_encode(LzContext *lz, LzImageType type, int width, int height, int top_down,
+              uint8_t *lines, unsigned int num_lines, int stride,
+              uint8_t *io_ptr, unsigned int num_io_bytes);
+
+/*
+        prepare encoder and read lz magic.
+        out_n_pixels number of compressed pixels. May differ from Width*height in plt1/4.
+        Use it for allocation the decompressed buffer.
+
+*/
+void lz_decode_begin(LzContext *lz, uint8_t *io_ptr, unsigned int num_io_bytes,
+                     LzImageType *out_type, int *out_width, int *out_height,
+                     int *out_n_pixels, int *out_top_down, const Palette *palette);
+
+/*
+        to_type = the image output type.
+        We assume the buffer is consecutive. i.e. width = stride
+
+        Improtant: if the image is plt1/4 and to_type is rgb32, the image
+        will decompressed including the last bits in each line. This means buffer should be
+        larger than width*height if neede and you shoud use stride to fix it.
+        Note: If the image is down to top, set the stride in the cairo surface to negative.
+        use cairo_image_surface_create_for_data to create the surface and
+        cairo_surface_set_user_data in order to free the data in the destroy callback.
+*/
+void lz_decode(LzContext *lz, LzImageType to_type, uint8_t *buf);
+
+LzContext *lz_create(LzUsrContext *usr);
+
+void lz_destroy(LzContext *lz);
+
+
+#endif  // __LZ_H
diff --git a/common/lz_common.h b/common/lz_common.h
new file mode 100644
index 00000000..75c32e2e
--- /dev/null
+++ b/common/lz_common.h
@@ -0,0 +1,60 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+/*common header for encoder and decoder*/
+
+#ifndef _LZ_COMMON_H
+#define _LZ_COMMON_H
+
+//#define DEBUG
+
+/* change the max window size will require change in the encoding format*/
+#define LZ_MAX_WINDOW_SIZE (1 << 25)
+#define MAX_COPY 32
+
+typedef enum {
+    LZ_IMAGE_TYPE_INVALID,
+    LZ_IMAGE_TYPE_PLT1_LE,
+    LZ_IMAGE_TYPE_PLT1_BE,      // PLT stands for palette
+    LZ_IMAGE_TYPE_PLT4_LE,
+    LZ_IMAGE_TYPE_PLT4_BE,
+    LZ_IMAGE_TYPE_PLT8,
+    LZ_IMAGE_TYPE_RGB16,
+    LZ_IMAGE_TYPE_RGB24,
+    LZ_IMAGE_TYPE_RGB32,
+    LZ_IMAGE_TYPE_RGBA
+} LzImageType;
+
+#define LZ_IMAGE_TYPE_MASK 0x0f
+#define LZ_IMAGE_TYPE_LOG 4 // number of bits required for coding the image type
+
+/* access to the arrays is based on the image types */
+static const int IS_IMAGE_TYPE_PLT[] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0};
+static const int IS_IMAGE_TYPE_RGB[] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
+static const int PLT_PIXELS_PER_BYTE[] = {0, 8, 8, 2, 2, 1};
+static const int RGB_BYTES_PER_PIXEL[] = {0, 1, 1, 1, 1, 1, 2, 3, 4, 4};
+
+
+#define LZ_MAGIC (*(uint32_t *)"LZ  ")
+#define LZ_VERSION_MAJOR 1U
+#define LZ_VERSION_MINOR 1U
+#define LZ_VERSION ((LZ_VERSION_MAJOR << 16) | (LZ_VERSION_MINOR & 0xffff))
+
+
+#endif  // _LZ_COMMON_H
diff --git a/common/lz_compress_tmpl.c b/common/lz_compress_tmpl.c
new file mode 100644
index 00000000..be1b941e
--- /dev/null
+++ b/common/lz_compress_tmpl.c
@@ -0,0 +1,523 @@
+/*
+
+ Copyright 2009 Red Hat, Inc. and/or its affiliates.
+
+ This program is licensed to you under the GNU General Public License,
+ version 2 or (at your option) any later version published by the Free
+ Software Foundation.  See the file COPYING for details.
+
+ There is NO WARRANTY for this software, not even the implied
+ warranties of MERCHANTABILITY, NONINFRINGEMENT, or FITNESS FOR A
+ PARTICULAR PURPOSE.
+
+ This file incorporates work covered by the following copyright and
+ permission notice:
+   Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the "Software"), to deal in the Software without
+   restriction, including without limitation the rights to use, copy,
+   modify, merge, publish, distribute, sublicense, and/or sell copies
+   of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+*/
+
+#define DJB2_START 5381;
+#define DJB2_HASH(hash, c) (hash = ((hash << 5) + hash) ^ (c)) //|{hash = ((hash << 5) + hash) + c;}
+
+/*
+    For each pixel type the following macros are defined:
+    PIXEL                         : input type
+    FNAME(name)
+    ENCODE_PIXEL(encoder, pixel) : writing a pixel to the compressed buffer (byte by byte)
+    SAME_PIXEL(pix1, pix2)         : comparing two pixels
+    HASH_FUNC(value, pix_ptr)    : hash func of 3 consecutive pixels
+*/
+
+#ifdef LZ_PLT
+#define PIXEL one_byte_pixel_t
+#define FNAME(name) lz_plt_##name
+#define ENCODE_PIXEL(e, pix) encode(e, (pix).a)   // gets the pixel and write only the needed bytes
+                                                  // from the pixel
+#define SAME_PIXEL(pix1, pix2) ((pix1).a == (pix2).a)
+#define HASH_FUNC(v, p) {  \
+    v = DJB2_START;        \
+    DJB2_HASH(v, p[0].a);  \
+    DJB2_HASH(v, p[1].a);  \
+    DJB2_HASH(v, p[2].a);  \
+    v &= HASH_MASK;        \
+    }
+#endif
+
+#ifdef LZ_RGB_ALPHA
+//#undef LZ_RGB_ALPHA
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) lz_rgb_alpha_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).pad);}
+#define SAME_PIXEL(pix1, pix2) ((pix1).pad == (pix2).pad)
+#define HASH_FUNC(v, p) {    \
+    v = DJB2_START;          \
+    DJB2_HASH(v, p[0].pad);  \
+    DJB2_HASH(v, p[1].pad);  \
+    DJB2_HASH(v, p[2].pad);  \
+    v &= HASH_MASK;          \
+    }
+#endif
+
+
+#ifdef LZ_RGB16
+#define PIXEL rgb16_pixel_t
+#define FNAME(name) lz_rgb16_##name
+#define GET_r(pix) (((pix) >> 10) & 0x1f)
+#define GET_g(pix) (((pix) >> 5) & 0x1f)
+#define GET_b(pix) ((pix) & 0x1f)
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix) >> 8); encode(e, (pix) & 0xff);}
+
+#define HASH_FUNC(v, p) {                 \
+    v = DJB2_START;                       \
+    DJB2_HASH(v, p[0] & (0x00ff));        \
+    DJB2_HASH(v, (p[0] >> 8) & (0x007f)); \
+    DJB2_HASH(v, p[1]&(0x00ff));          \
+    DJB2_HASH(v, (p[1] >> 8) & (0x007f)); \
+    DJB2_HASH(v, p[2] & (0x00ff));        \
+    DJB2_HASH(v, (p[2] >> 8) & (0x007f)); \
+    v &= HASH_MASK;                       \
+}
+#endif
+
+#ifdef LZ_RGB24
+#define PIXEL rgb24_pixel_t
+#define FNAME(name) lz_rgb24_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
+#endif
+
+#ifdef LZ_RGB32
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) lz_rgb32_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
+#endif
+
+
+#if  defined(LZ_RGB24) || defined(LZ_RGB32)
+#define GET_r(pix) ((pix).r)
+#define GET_g(pix) ((pix).g)
+#define GET_b(pix) ((pix).b)
+#define HASH_FUNC(v, p) {    \
+    v = DJB2_START;          \
+    DJB2_HASH(v, p[0].r);    \
+    DJB2_HASH(v, p[0].g);    \
+    DJB2_HASH(v, p[0].b);    \
+    DJB2_HASH(v, p[1].r);    \
+    DJB2_HASH(v, p[1].g);    \
+    DJB2_HASH(v, p[1].b);    \
+    DJB2_HASH(v, p[2].r);    \
+    DJB2_HASH(v, p[2].g);    \
+    DJB2_HASH(v, p[2].b);    \
+    v &= HASH_MASK;          \
+    }
+#endif
+
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+#define SAME_PIXEL(p1, p2) (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) && \
+                            GET_b(p1) == GET_b(p2))
+
+#endif
+
+#define PIXEL_ID(pix_ptr, seg_ptr) (pix_ptr - ((PIXEL *)seg_ptr->lines) + seg_ptr->size_delta)
+
+// when encoding, the ref can be in previous segment, and we should check that it doesn't
+// exceeds its bounds.
+// TODO: optimization: when only one chunk exists or when the reference is in the same segement,
+//       don't make checks if we reach end of segements
+// TODO: optimize to continue match between segments?
+// TODO: check hash function
+// TODO: check times
+
+/* compresses one segment starting from 'from'.*/
+static void FNAME(compress_seg)(Encoder *encoder, LzImageSegment *seg, PIXEL *from, int copied)
+{
+    const PIXEL *ip = from;
+    const PIXEL *ip_bound = (PIXEL *)(seg->lines_end) - BOUND_OFFSET;
+    const PIXEL *ip_limit = (PIXEL *)(seg->lines_end) - LIMIT_OFFSET;
+    HashEntry    *hslot;
+    int hval;
+    int copy = copied;
+
+    if (copy == 0) {
+        encode_copy_count(encoder, MAX_COPY - 1);
+    }
+
+
+    while (LZ_EXPECT_CONDITIONAL(ip < ip_limit)) {   // TODO: maybe change ip_limit and enabling
+                                                     //       moving to the next seg
+        const PIXEL            *ref;
+        const PIXEL            *ref_limit;
+        size_t distance;
+
+        /* minimum match length */
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+        size_t len = 3;
+#elif defined(LZ_RGB16)
+        size_t len = 2;
+#else
+        size_t len = 1;
+#endif
+        /* comparison starting-point */
+        const PIXEL            *anchor = ip;
+
+
+
+        // TODO: RLE without checking if not first byte.
+        // TODO: optimize comparisons
+
+        /* check for a run */ // TODO for RGB we can use less pixels
+        if (LZ_EXPECT_CONDITIONAL(ip > (PIXEL *)(seg->lines))) {
+            if (SAME_PIXEL(ip[-1], ip[0]) && SAME_PIXEL(ip[0], ip[1]) && SAME_PIXEL(ip[1], ip[2])) {
+                distance = 1;
+                ip += 3;
+                ref = anchor + 2;
+                ref_limit = (PIXEL *)(seg->lines_end);
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+                len = 3;
+#endif
+                goto match;
+            }
+        }
+
+        /* find potential match */
+        HASH_FUNC(hval, ip);
+        hslot = encoder->htab + hval;
+        ref = (PIXEL *)(hslot->ref);
+        ref_limit = (PIXEL *)(hslot->image_seg->lines_end);
+
+        /* calculate distance to the match */
+        distance = PIXEL_ID(anchor, seg) - PIXEL_ID(ref, hslot->image_seg);
+
+        /* update hash table */
+        hslot->image_seg = seg;
+        hslot->ref = (uint8_t *)anchor;
+
+        /* is this a match? check the first 3 pixels */
+        if (distance == 0 || (distance >= MAX_FARDISTANCE)) {
+            goto literal;
+        }
+        /* check if the hval key identical*/
+        // no need to check ref limit here because the word size in the htab is 3 pixels
+        if (!SAME_PIXEL(*ref, *ip)) {
+            ref++;
+            ip++;
+            goto literal;
+        }
+        ref++;
+        ip++;
+
+        /* minimum match length for rgb16 is 2 and for plt and alpha is 3 */
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA) || defined(LZ_RGB16)
+        if (!SAME_PIXEL(*ref, *ip)) {
+            ref++;
+            ip++;
+            goto literal;
+        }
+        ref++;
+        ip++;
+#endif
+
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+        if (!SAME_PIXEL(*ref, *ip)) {
+            ref++;
+            ip++;
+            goto literal;
+        }
+        ref++;
+        ip++;
+#endif
+        /* far, needs at least 5-byte match */
+        if (distance >= MAX_DISTANCE) {
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+            if (ref >= (ref_limit - 1)) {
+                goto literal;
+            }
+#else
+            if (ref > (ref_limit - 1)) {
+                goto literal;
+            }
+#endif
+            if (!SAME_PIXEL(*ref, *ip)) {
+                ref++;
+                ip++;
+                goto literal;
+            }
+            ref++;
+            ip++;
+            len++;
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+            if (!SAME_PIXEL(*ref, *ip)) {
+                ref++;
+                ip++;
+                goto literal;
+            }
+            ref++;
+            ip++;
+            len++;
+#endif
+        }
+match:        // RLE or dictionary (both are encoded by distance from ref (-1) and length)
+
+        /* distance is biased */
+        distance--;
+
+        // ip is located now at the position of the second mismatch.
+        // later it will be substracted by 3
+
+        if (!distance) {
+            /* zero distance means a run */
+            PIXEL x = *ref;
+            while ((ip < ip_bound) && (ref < ref_limit)) { // TODO: maybe separate a run from
+                                                           //       the same seg or from different
+                                                           //       ones in order to spare 
+                                                           //       ref < ref_limit
+                if (!SAME_PIXEL(*ref, x)) {
+                    ref++;
+                    break;
+                } else {
+                    ref++;
+                    ip++;
+                }
+            }
+        } else {
+            // TODO: maybe separate a run from the same seg or from different ones in order
+            //       to spare ref < ref_limit and that way we can also perform 8 calls of
+            //       (ref++ != ip++) outside a loop
+            for (;;) {
+                while ((ip < ip_bound) && (ref < ref_limit)) {
+                    if (!SAME_PIXEL(*ref, *ip)) {
+                        ref++;
+                        ip++;
+                        break;
+                    } else {
+                        ref++;
+                        ip++;
+                    }
+                }
+                break;
+            }
+        }
+
+        /* if we have copied something, adjust the copy count */
+        if (copy) {
+            /* copy is biased, '0' means 1 byte copy */
+            update_copy_count(encoder, copy - 1);
+        } else {
+            /* back, to overwrite the copy count */
+            compress_output_prev(encoder);
+        }
+
+        /* reset literal counter */
+        copy = 0;
+
+        /* length is biased, '1' means a match of 3 pixels for PLT and alpha*/
+        /* for RGB 16 1 means 2 */
+        /* for RGB24/32 1 means 1...*/
+        ip -= 3;
+        len = ip - anchor;
+#if defined(LZ_RGB16)
+        len++;
+#elif defined(LZ_RGB24) || defined(LZ_RGB32)
+        len += 2;
+#endif
+        /* encode the match (like fastlz level 2)*/
+        if (distance < MAX_DISTANCE) { // MAX_DISTANCE is 2^13 - 1
+            // when copy is pefrformed, the byte that holds the copy count is smaller than 32.
+            // When there is a reference, the first byte is always larger then 32
+
+            // 3 bits = length, 5 bits = 5 MSB of distance, 8 bits = 8 LSB of distance
+            if (len < 7) {
+                encode(encoder, (uint8_t)((len << 5) + (distance >> 8)));
+                encode(encoder, (uint8_t)(distance & 255));
+            } else { // more than 3 bits are needed for length
+                    // 3 bits 7, 5 bits = 5 MSB of distance, next bytes are 255 till we
+                    // recieve a smaller number, last byte = 8 LSB of distance
+                encode(encoder, (uint8_t)((7 << 5) + (distance >> 8)));
+                for (len -= 7; len >= 255; len -= 255) {
+                    encode(encoder, 255);
+                }
+                encode(encoder, (uint8_t)len);
+                encode(encoder, (uint8_t)(distance & 255));
+            }
+        } else {
+            /* far away */
+            if (len < 7) { // the max_far_distance is ~2^16+2^13 so two more bytes are needed
+                // 3 bits = length, 5 bits = 5 MSB of MAX_DISTANCE, 8 bits = 8 LSB of MAX_DISTANCE,
+                // 8 bits = 8 MSB distance-MAX_distance (smaller than 2^16),8 bits=8 LSB of
+                // distance-MAX_distance
+                distance -= MAX_DISTANCE;
+                encode(encoder, (uint8_t)((len << 5) + 31));
+                encode(encoder, (uint8_t)255);
+                encode(encoder, (uint8_t)(distance >> 8));
+                encode(encoder, (uint8_t)(distance & 255));
+            } else {
+                // same as before, but the first byte is followed by the left overs of len
+                distance -= MAX_DISTANCE;
+                encode(encoder, (uint8_t)((7 << 5) + 31));
+                for (len -= 7; len >= 255; len -= 255) {
+                    encode(encoder, 255);
+                }
+                encode(encoder, (uint8_t)len);
+                encode(encoder, 255);
+                encode(encoder, (uint8_t)(distance >> 8));
+                encode(encoder, (uint8_t)(distance & 255));
+            }
+        }
+
+        /* update the hash at match boundary */
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+        if (ip > anchor) {
+#endif
+        HASH_FUNC(hval, ip);
+        encoder->htab[hval].ref = (uint8_t *)ip;
+        ip++;
+        encoder->htab[hval].image_seg = seg;
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+    } else {ip++;
+    }
+#endif
+#if defined(LZ_RGB24) || defined(LZ_RGB32)
+        if (ip > anchor) {
+#endif
+        HASH_FUNC(hval, ip);
+        encoder->htab[hval].ref = (uint8_t *)ip;
+        ip++;
+        encoder->htab[hval].image_seg = seg;
+#if defined(LZ_RGB24) || defined(LZ_RGB32)
+    } else {ip++;
+    }
+#endif
+        /* assuming literal copy */
+        encode_copy_count(encoder, MAX_COPY - 1);
+        continue;
+
+literal:
+        ENCODE_PIXEL(encoder, *anchor);
+        anchor++;
+        ip = anchor;
+        copy++;
+
+        if (LZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY)) {
+            copy = 0;
+            encode_copy_count(encoder, MAX_COPY - 1);
+        }
+    } // END LOOP (ip < ip_limit)
+
+
+    /* left-over as literal copy */
+    ip_bound++;
+    while (ip <= ip_bound) {
+        ENCODE_PIXEL(encoder, *ip);
+        ip++;
+        copy++;
+        if (copy == MAX_COPY) {
+            copy = 0;
+            encode_copy_count(encoder, MAX_COPY - 1);
+        }
+    }
+
+    /* if we have copied something, adjust the copy length */
+    if (copy) {
+        update_copy_count(encoder, copy - 1);
+    } else {
+        compress_output_prev(encoder); // in case we created a new buffer for copy, check that
+                                       // red_worker could handle size that do not contain the
+                                       // ne buffer
+    }
+}
+
+
+/*    initializes the hash table. if the file is very small, copies it.
+    copies the first two pixels of the first segment, and sends the segments
+    one by one to compress_seg.
+    the number of bytes compressed are stored inside encoder.
+    */
+static void FNAME(compress)(Encoder *encoder)
+{
+    LzImageSegment    *cur_seg = encoder->head_image_segs;
+    HashEntry        *hslot;
+    PIXEL            *ip;
+
+    // fetch the first image segment that is not too small
+    while (cur_seg && ((((PIXEL *)cur_seg->lines_end) - ((PIXEL *)cur_seg->lines)) < 4)) {
+        // coping the segment
+        if (cur_seg->lines != cur_seg->lines_end) {
+            ip = (PIXEL *)cur_seg->lines;
+            // Note: we assume MAX_COPY > 3
+            encode_copy_count(encoder, (uint8_t)(
+                                  (((PIXEL *)cur_seg->lines_end) - ((PIXEL *)cur_seg->lines)) - 1));
+            while (ip < (PIXEL *)cur_seg->lines_end) {
+                ENCODE_PIXEL(encoder, *ip);
+                ip++;
+            }
+        }
+        cur_seg = cur_seg->next;
+    }
+
+    if (!cur_seg) {
+        return;
+    }
+
+    ip = (PIXEL *)cur_seg->lines;
+
+    /* initialize hash table */
+    for (hslot = encoder->htab; hslot < encoder->htab + HASH_SIZE; hslot++) {
+        hslot->ref = (uint8_t*)ip;
+        hslot->image_seg = cur_seg;
+    }
+
+    encode_copy_count(encoder, MAX_COPY - 1);
+    ENCODE_PIXEL(encoder, *ip);
+    ip++;
+    ENCODE_PIXEL(encoder, *ip);
+    ip++;
+
+    // compressing the first segment
+    FNAME(compress_seg)(encoder, cur_seg, ip, 2);
+
+    // compressing the next segments
+    for (cur_seg = cur_seg->next; cur_seg; cur_seg = cur_seg->next) {
+        FNAME(compress_seg)(encoder, cur_seg, (PIXEL *)cur_seg->lines, 0);
+    }
+}
+
+#undef FNAME
+#undef PIXEL_ID
+#undef PIXEL
+#undef ENCODE_PIXEL
+#undef SAME_PIXEL
+#undef LZ_READU16
+#undef HASH_FUNC
+#undef BYTES_TO_16
+#undef HASH_FUNC_16
+#undef GET_r
+#undef GET_g
+#undef GET_b
+#undef GET_CODE
+#undef LZ_PLT
+#undef LZ_RGB_ALPHA
+#undef LZ_RGB16
+#undef LZ_RGB24
+#undef LZ_RGB32
+#undef HASH_FUNC2
diff --git a/common/lz_config.h b/common/lz_config.h
new file mode 100644
index 00000000..1020e7ba
--- /dev/null
+++ b/common/lz_config.h
@@ -0,0 +1,59 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef __LZ_CONFIG_H
+#define __LZ_CONFIG_H
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+
+#ifdef __GNUC__
+
+#include <stdint.h>
+#include <string.h>
+
+#define INLINE inline
+
+#else
+
+#ifdef QXLDD
+#include <windef.h>
+#include "os_dep.h"
+#define INLINE _inline
+
+#else
+#include <stddef.h>
+#include <basetsd.h>
+#include <string.h>
+
+#define INLINE inline
+#endif  // QXLDD
+
+typedef UINT32 uint32_t;
+typedef UINT16 uint16_t;
+typedef UINT8 uint8_t;
+
+#endif  //__GNUC__
+#endif  //__LZ_CONFIG_H
diff --git a/common/lz_decompress_tmpl.c b/common/lz_decompress_tmpl.c
new file mode 100644
index 00000000..36502c66
--- /dev/null
+++ b/common/lz_decompress_tmpl.c
@@ -0,0 +1,317 @@
+/*
+
+ Copyright 2009 Red Hat, Inc. and/or its affiliates.
+
+ This program is licensed to you under the GNU General Public License,
+ version 2 or (at your option) any later version published by the Free
+ Software Foundation.  See the file COPYING for details.
+
+ There is NO WARRANTY for this software, not even the implied
+ warranties of MERCHANTABILITY, NONINFRINGEMENT, or FITNESS FOR A
+ PARTICULAR PURPOSE.
+
+ This file incorporates work covered by the following copyright and
+ permission notice:
+      Copyright (C) 2007 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2006 Ariya Hidayat (ariya@kde.org)
+   Copyright (C) 2005 Ariya Hidayat (ariya@kde.org)
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the "Software"), to deal in the Software without
+   restriction, including without limitation the rights to use, copy,
+   modify, merge, publish, distribute, sublicense, and/or sell copies
+   of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+*/
+
+// External defines: PLT, RGBX/PLTXX/ALPHA, TO_RGB32.
+// If PLT4/1 and TO_RGB32 are defined, we need CAST_PLT_DISTANCE (because then the number of
+// pixels differ from the units used in the compression)
+
+/*
+    For each output pixel type the following macros are defined:
+    OUT_PIXEL                      - the output pixel type
+    COPY_PIXEL(p, out)              - assignes the pixel to the place pointed by out and increases
+                                      out. Used in RLE. Need special handling because in alpha we
+                                      copy only the pad byte.
+    COPY_REF_PIXEL(ref, out)      - copies the pixel pointed by ref to the pixel pointed by out.
+                                    Increases ref and out.
+    COPY_COMP_PIXEL(encoder, out) - copies pixel from the compressed buffer to the decompressed
+                                    buffer. Increases out.
+*/
+#if !defined(LZ_RGB_ALPHA)
+#define COPY_PIXEL(p, out) (*out++ = p)
+#define COPY_REF_PIXEL(ref, out) (*out++ = *ref++)
+#endif
+
+
+// decompressing plt to plt
+#ifdef LZ_PLT
+#ifndef TO_RGB32
+#define OUT_PIXEL one_byte_pixel_t
+#define FNAME(name) lz_plt_##name
+#define COPY_COMP_PIXEL(encoder, out) {out->a = decode(encoder); out++;}
+#else // TO_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define COPY_PLT_ENTRY(ent, out) {    \
+    (out)->b = ent;                   \
+    (out)->g = (ent >> 8);            \
+    (out)->r = (ent >> 16);           \
+    (out)->pad = 0;                   \
+}
+#ifdef PLT8
+#define FNAME(name) lz_plt8_to_rgb32_##name
+#define COPY_COMP_PIXEL(encoder, out) {                     \
+    uint32_t rgb = encoder->palette->ents[decode(encoder)]; \
+    COPY_PLT_ENTRY(rgb, out);                               \
+    out++;}
+#elif defined(PLT4_BE)
+#define FNAME(name) lz_plt4_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(encoder, out){                                                             \
+    uint8_t byte = decode(encoder);                                                                \
+    uint32_t rgb = encoder->palette->ents[((byte >> 4) & 0x0f) % (encoder->palette->num_ents)];    \
+    COPY_PLT_ENTRY(rgb, out);                                                                      \
+    out++;                                                                                         \
+    rgb = encoder->palette->ents[(byte & 0x0f) % (encoder->palette->num_ents)];                    \
+    COPY_PLT_ENTRY(rgb, out);                                                                      \
+    out++;                                                                                         \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif  defined(PLT4_LE)
+#define FNAME(name) lz_plt4_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(encoder, out){                                                      \
+    uint8_t byte = decode(encoder);                                                         \
+    uint32_t rgb = encoder->palette->ents[(byte & 0x0f) % (encoder->palette->num_ents)];    \
+    COPY_PLT_ENTRY(rgb, out);                                                               \
+    out++;                                                                                  \
+    rgb = encoder->palette->ents[((byte >> 4) & 0x0f) % (encoder->palette->num_ents)];      \
+    COPY_PLT_ENTRY(rgb, out);                                                               \
+    out++;                                                                                  \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*2)
+#elif defined(PLT1_BE) // TODO store palette entries for direct access
+#define FNAME(name) lz_plt1_be_to_rgb32_##name
+#define COPY_COMP_PIXEL(encoder, out){                                    \
+    uint8_t byte = decode(encoder);                                       \
+    int i;                                                                \
+    uint32_t fore = encoder->palette->ents[1];                            \
+    uint32_t back = encoder->palette->ents[0];                            \
+    for (i = 7; i >= 0; i--)                                              \
+    {                                                                     \
+        if ((byte >> i) & 1) {                                            \
+            COPY_PLT_ENTRY(fore, out);                                    \
+        } else {                                                          \
+            COPY_PLT_ENTRY(back, out);                                    \
+        }                                                                 \
+        out++;                                                            \
+    }                                                                     \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#elif defined(PLT1_LE)
+#define FNAME(name) lz_plt1_le_to_rgb32_##name
+#define COPY_COMP_PIXEL(encoder, out){                                    \
+    uint8_t byte = decode(encoder);                                       \
+    int i;                                                                \
+    uint32_t fore = encoder->palette->ents[1];                            \
+    uint32_t back = encoder->palette->ents[0];                            \
+    for (i = 0; i < 8; i++)                                               \
+    {                                                                     \
+        if ((byte >> i) & 1) {                                            \
+            COPY_PLT_ENTRY(fore, out);                                    \
+        } else {                                                          \
+            COPY_PLT_ENTRY(back, out);                                    \
+        }                                                                 \
+        out++;                                                            \
+    }                                                                     \
+}
+#define CAST_PLT_DISTANCE(dist) (dist*8)
+#endif // PLT Type
+#endif // TO_RGB32
+#endif
+
+#ifdef LZ_RGB16
+#ifndef TO_RGB32
+#define OUT_PIXEL rgb16_pixel_t
+#define FNAME(name) lz_rgb16_##name
+#define COPY_COMP_PIXEL(e, out) {*out = ((decode(e) << 8) | decode(e)); out++;}
+#else
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) lz_rgb16_to_rgb32_##name
+#define COPY_COMP_PIXEL(e, out) {                                      \
+    out->r = decode(e);                                                \
+    out->b = decode(e);                                                \
+    out->g = (((out->r) << 6) | ((out->b) >> 2)) & ~0x07;              \
+    out->g |= (out->g >> 5);                                           \
+    out->r = ((out->r << 1) & ~0x07)| ((out->r >> 4) & 0x07);          \
+    out->b =  (out->b << 3) | ((out->b >> 2) & 0x07);                  \
+    out->pad = 0;                                                      \
+    out++;                                                             \
+}                                                        
+#endif
+#endif
+
+#ifdef LZ_RGB24
+#define OUT_PIXEL rgb24_pixel_t
+#define FNAME(name) lz_rgb24_##name
+#define COPY_COMP_PIXEL(e, out) {out->b = decode(e); out->g = decode(e); out->r = decode(e); out++;}
+#endif
+
+#ifdef LZ_RGB32
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) lz_rgb32_##name
+#define COPY_COMP_PIXEL(e, out) {   \
+    out->b = decode(e);             \
+    out->g = decode(e);             \
+    out->r = decode(e);             \
+    out->pad = 0;                   \
+    out++;                          \
+}
+#endif
+
+#ifdef LZ_RGB_ALPHA
+#define OUT_PIXEL rgb32_pixel_t
+#define FNAME(name) lz_rgb_alpha_##name
+#define COPY_PIXEL(p, out) {out->pad = p.pad; out++;}
+#define COPY_REF_PIXEL(ref, out) {out->pad = ref->pad; out++; ref++;}
+#define COPY_COMP_PIXEL(e, out) {out->pad = decode(e); out++;}
+#endif
+
+// return num of bytes in out_buf
+static size_t FNAME(decompress)(Encoder *encoder, OUT_PIXEL *out_buf, int size)
+{
+    OUT_PIXEL    *op = out_buf;
+    OUT_PIXEL    *op_limit = out_buf + size;
+    uint32_t ctrl = decode(encoder);
+    int loop = TRUE;
+
+    do {
+        const OUT_PIXEL *ref = op;
+        uint32_t len = ctrl >> 5;
+        uint32_t ofs = (ctrl & 31) << 8; // 5 MSb of distance
+
+        if (ctrl >= MAX_COPY) { // reference (dictionary/RLE)
+            /* retrieving the reference and the match length */
+
+            uint8_t code;
+            len--;
+            //ref -= ofs;
+            if (len == 7 - 1) { // match length is bigger than 7
+                do {
+                    code = decode(encoder);
+                    len += code;
+                } while (code == 255); // remaining of len
+            }
+            code = decode(encoder);
+            ofs += code;
+
+            /* match from 16-bit distance */
+            if (LZ_UNEXPECT_CONDITIONAL(code == 255)) {
+                if (LZ_EXPECT_CONDITIONAL((ofs - code) == (31 << 8))) {
+                    ofs = decode(encoder) << 8;
+                    ofs += decode(encoder);
+                    ofs += MAX_DISTANCE;
+                }
+            }
+
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+            len += 3; // length is biased by 2 + 1 (fixing bias)
+#elif defined(LZ_RGB16)
+            len += 2; // length is biased by 1 + 1 (fixing bias)
+#else
+            len += 1;
+#endif
+            ofs += 1; // offset is biased by 1       (fixing bias)
+
+#if defined(TO_RGB32)
+#if defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || defined(PLT1_LE)
+            ofs = CAST_PLT_DISTANCE(ofs);
+            len = CAST_PLT_DISTANCE(len);
+#endif
+#endif
+            ref -= ofs;
+
+            ASSERT(encoder->usr, op + len <= op_limit);
+            ASSERT(encoder->usr, ref + len <= op_limit);
+            ASSERT(encoder->usr, ref >= out_buf);
+
+            // TODO: optimize by not calling loop at least 3 times when not PLT_TO_RGB32 (len is
+            //       always >=3). in PLT_TO_RGB32 len >= 3*number_of_pixels_per_byte
+
+            /* copying the match*/
+
+            if (ref == (op - 1)) { // run // TODO: this will never be called in PLT4/1_TO_RGB
+                                          //       because the number of pixel copied is larger
+                                          //       then one...
+                /* optimize copy for a run */
+                OUT_PIXEL b = *ref;
+                for (; len; --len) {
+                    COPY_PIXEL(b, op);
+                    ASSERT(encoder->usr, op <= op_limit);
+                }
+            } else {
+                for (; len; --len) {
+                    COPY_REF_PIXEL(ref, op);
+                    ASSERT(encoder->usr, op <= op_limit);
+                }
+            }
+        } else { // copy
+            ctrl++; // copy count is biased by 1
+#if defined(TO_RGB32) && (defined(PLT4_BE) || defined(PLT4_LE) || defined(PLT1_BE) || \
+                                                                                   defined(PLT1_LE))
+            ASSERT(encoder->usr, op + CAST_PLT_DISTANCE(ctrl) <= op_limit);
+#else
+            ASSERT(encoder->usr, op + ctrl <= op_limit);
+#endif
+            COPY_COMP_PIXEL(encoder, op);
+
+            ASSERT(encoder->usr, op <= op_limit);
+
+            for (--ctrl; ctrl; ctrl--) {
+                COPY_COMP_PIXEL(encoder, op);
+                ASSERT(encoder->usr, op <= op_limit);
+            }
+        }
+
+        if (LZ_EXPECT_CONDITIONAL(op < op_limit)) {
+            ctrl = decode(encoder);
+        } else {
+            loop = FALSE;
+        }
+    } while (LZ_EXPECT_CONDITIONAL(loop));
+
+    return (op - out_buf);
+}
+
+#undef LZ_PLT
+#undef PLT8
+#undef PLT4_BE
+#undef PLT4_LE
+#undef PLT1_BE
+#undef PLT1_LE
+#undef LZ_RGB16
+#undef LZ_RGB24
+#undef LZ_RGB32
+#undef LZ_RGB_ALPHA
+#undef TO_RGB32
+#undef OUT_PIXEL
+#undef FNAME
+#undef COPY_PIXEL
+#undef COPY_REF_PIXEL
+#undef COPY_COMP_PIXEL
+#undef COPY_PLT_ENTRY
+#undef CAST_PLT_DISTANCE
+
diff --git a/common/mutex.h b/common/mutex.h
new file mode 100644
index 00000000..373d54e0
--- /dev/null
+++ b/common/mutex.h
@@ -0,0 +1,34 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_MUTEX
+#define _H_MUTEX
+#ifdef _WIN32
+#include <windows.h>
+typedef CRITICAL_SECTION mutex_t;
+#define MUTEX_INIT(mutex) InitializeCriticalSection(&mutex)
+#define MUTEX_LOCK(mutex) EnterCriticalSection(&mutex)
+#define MUTEX_UNLOCK(mutex) LeaveCriticalSection(&mutex)
+#else
+#include <pthread.h>
+typedef pthread_mutex_t mutex_t;
+#define MUTEX_INIT(mutex) pthread_mutex_init(&mutex, NULL);
+#define MUTEX_LOCK(mutex) pthread_mutex_lock(&mutex)
+#define MUTEX_UNLOCK(mutex) pthread_mutex_unlock(&mutex)
+#endif
+
+#endif // _H_MUTEX
diff --git a/common/ogl_ctx.c b/common/ogl_ctx.c
new file mode 100644
index 00000000..6b175115
--- /dev/null
+++ b/common/ogl_ctx.c
@@ -0,0 +1,253 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <GL/glx.h>
+
+#include "ogl_ctx.h"
+
+
+#define PANIC(str) {                                \
+    printf("%s: panic: %s", __FUNCTION__, str);     \
+    abort();                                        \
+}
+
+enum {
+    OGLCTX_TYPE_PBUF,
+    OGLCTX_TYPE_PIXMAP,
+};
+
+struct OGLCtx {
+    int type;
+    Display *x_display;
+    GLXContext glx_context;
+    GLXDrawable drawable;
+};
+
+typedef struct OGLPixmapCtx {
+    OGLCtx base;
+    Pixmap pixmap;
+} OGLPixmapCtx;
+
+
+
+const char *oglctx_type_str(OGLCtx *ctx)
+{
+    static const char *pbuf_str = "pbuf";
+    static const char *pixmap_str = "pixmap";
+    static const char *invalid_str = "invalid";
+
+    switch (ctx->type) {
+    case OGLCTX_TYPE_PBUF:
+        return pbuf_str;
+    case OGLCTX_TYPE_PIXMAP:
+        return pixmap_str;
+    default:
+        return invalid_str;
+    }
+}
+
+void oglctx_make_current(OGLCtx *ctx)
+{
+    if (!glXMakeCurrent(ctx->x_display, ctx->drawable, ctx->glx_context)) {
+        printf("%s: failed\n", __FUNCTION__);
+    }
+}
+
+OGLCtx *pbuf_create(int width, int heigth)
+{
+    OGLCtx *ctx;
+    Display *x_display;
+    int num_configs;
+    GLXFBConfig *fb_config;
+    GLXPbuffer glx_pbuf;
+    GLXContext glx_context;
+
+    const int glx_attributes[] = {  GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                                    GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
+                                    GLX_RED_SIZE, 8,
+                                    GLX_GREEN_SIZE, 8,
+                                    GLX_BLUE_SIZE, 8,
+                                    GLX_ALPHA_SIZE, 8,
+                                    GLX_STENCIL_SIZE, 4,
+                                    0 };
+
+    int pbuf_attrib[] = { GLX_PRESERVED_CONTENTS, True,
+                          GLX_PBUFFER_WIDTH, width,
+                          GLX_PBUFFER_HEIGHT, heigth,
+                          GLX_LARGEST_PBUFFER, False,
+                          0, 0 };
+
+    if (!(ctx = calloc(1, sizeof(*ctx)))) {
+        printf("%s: alloc pbuf failed\n", __FUNCTION__);
+        return NULL;
+    }
+
+    if (!(x_display = XOpenDisplay(NULL))) {
+        printf("%s: open display failed\n", __FUNCTION__);
+        goto error_1;
+    }
+
+    if (!(fb_config = glXChooseFBConfig(x_display, 0, glx_attributes, &num_configs)) ||
+                                                                            !num_configs) {
+        printf("%s: choose fb config failed\n", __FUNCTION__);
+        goto error_2;
+    }
+
+    if (!(glx_pbuf = glXCreatePbuffer(x_display, fb_config[0], pbuf_attrib))) {
+        goto error_3;
+    }
+
+    if (!(glx_context = glXCreateNewContext(x_display, fb_config[0], GLX_RGBA_TYPE, NULL, True))) {
+        printf("%s: create context failed\n", __FUNCTION__);
+        goto error_4;
+    }
+
+    XFree(fb_config);
+
+    ctx->type = OGLCTX_TYPE_PBUF;
+    ctx->drawable = glx_pbuf;
+    ctx->glx_context = glx_context;
+    ctx->x_display = x_display;
+
+    return ctx;
+
+error_4:
+    glXDestroyPbuffer(x_display, glx_pbuf);
+
+error_3:
+    XFree(fb_config);
+
+error_2:
+    XCloseDisplay(x_display);
+
+error_1:
+    free(ctx);
+
+    return NULL;
+}
+
+OGLCtx *pixmap_create(int width, int heigth)
+{
+    Display *x_display;
+    int num_configs;
+    GLXFBConfig *fb_config;
+    GLXPixmap glx_pixmap;
+    GLXContext glx_context;
+    Pixmap pixmap;
+    int screen;
+    Window root_window;
+    OGLPixmapCtx *pix;
+
+    const int glx_attributes[] = {  GLX_RENDER_TYPE, GLX_RGBA_BIT,
+                                    GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
+                                    GLX_RED_SIZE, 8,
+                                    GLX_GREEN_SIZE, 8,
+                                    GLX_BLUE_SIZE, 8,
+                                    GLX_ALPHA_SIZE, 8,
+                                    GLX_STENCIL_SIZE, 4,
+                                    0 };
+
+    if (!(pix = calloc(1, sizeof(*pix)))) {
+        printf("%s: alloc pix failed\n", __FUNCTION__);
+        return NULL;
+    }
+
+    if (!(x_display = XOpenDisplay(NULL))) {
+        printf("%s: open display failed\n", __FUNCTION__);
+        goto error_1;
+    }
+
+    screen = DefaultScreen(x_display);
+    root_window = RootWindow(x_display, screen);
+
+    if (!(fb_config = glXChooseFBConfig(x_display, 0, glx_attributes, &num_configs)) ||
+                                                                              !num_configs) {
+        printf("%s: choose fb config failed\n", __FUNCTION__);
+        goto error_2;
+    }
+
+    if (!(pixmap = XCreatePixmap(x_display, root_window, width, heigth, 32 /*use fb config*/))) {
+        printf("%s: create x pixmap failed\n", __FUNCTION__);
+        goto error_3;
+    }
+
+    if (!(glx_pixmap = glXCreatePixmap(x_display, fb_config[0], pixmap, NULL))) {
+        printf("%s: create glx pixmap failed\n", __FUNCTION__);
+        goto error_4;
+    }
+
+
+    if (!(glx_context = glXCreateNewContext(x_display, fb_config[0], GLX_RGBA_TYPE, NULL, True))) {
+        printf("%s: create context failed\n", __FUNCTION__);
+        goto error_5;
+    }
+
+    XFree(fb_config);
+
+    pix->base.type = OGLCTX_TYPE_PIXMAP;
+    pix->base.x_display = x_display;
+    pix->base.drawable = glx_pixmap;
+    pix->base.glx_context = glx_context;
+    pix->pixmap = pixmap;
+
+    return &pix->base;
+
+error_5:
+    glXDestroyPixmap(x_display, glx_pixmap);
+
+error_4:
+    XFreePixmap(x_display, pixmap);
+
+error_3:
+    XFree(fb_config);
+
+error_2:
+    XCloseDisplay(x_display);
+
+error_1:
+    free(pix);
+
+    return NULL;
+}
+
+void oglctx_destroy(OGLCtx *ctx)
+{
+    if (!ctx) {
+        return;
+    }
+    // test is current ?
+
+    glXDestroyContext(ctx->x_display, ctx->glx_context);
+    switch (ctx->type) {
+    case OGLCTX_TYPE_PBUF:
+        glXDestroyPbuffer(ctx->x_display, ctx->drawable);
+        break;
+    case OGLCTX_TYPE_PIXMAP:
+        glXDestroyPixmap(ctx->x_display, ctx->drawable);
+        XFreePixmap(ctx->x_display, ((OGLPixmapCtx *)ctx)->pixmap);
+        break;
+    default:
+        PANIC("invalid ogl ctx type");
+    }
+
+    XCloseDisplay(ctx->x_display);
+    free(ctx);
+}
+
diff --git a/common/ogl_ctx.h b/common/ogl_ctx.h
new file mode 100644
index 00000000..85a551ab
--- /dev/null
+++ b/common/ogl_ctx.h
@@ -0,0 +1,30 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLCTX
+#define _H_GLCTX
+
+typedef struct OGLCtx OGLCtx;
+
+const char *oglctx_type_str(OGLCtx *ctx);
+void oglctx_make_current(OGLCtx *ctx);
+OGLCtx *pbuf_create(int width, int heigth);
+OGLCtx *pixmap_create(int width, int heigth);
+void oglctx_destroy(OGLCtx *ctx);
+
+#endif
+
diff --git a/common/quic.c b/common/quic.c
new file mode 100644
index 00000000..7568f9e1
--- /dev/null
+++ b/common/quic.c
@@ -0,0 +1,1709 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+// Red Hat image compression based on SFALIC by Roman Starosolski
+// http://sun.iinf.polsl.gliwice.pl/~rstaros/sfalic/index.html
+
+#include "quic.h"
+
+//#define DEBUG
+
+#define RLE
+#define RLE_STAT
+#define PRED_1
+//#define RLE_PRED_1
+#define RLE_PRED_2
+//#define RLE_PRED_3
+#define QUIC_RGB
+
+#define QUIC_MAGIC (*(uint32_t *)"QUIC")
+#define QUIC_VERSION_MAJOR 0U
+#define QUIC_VERSION_MINOR 1U
+#define QUIC_VERSION ((QUIC_VERSION_MAJOR << 16) | (QUIC_VERSION_MAJOR & 0xffff))
+
+#define ABS(a) ((a) >= 0 ? (a) : -(a))
+
+#ifdef DEBUG
+
+#define ASSERT(usr, x) \
+    if (!(x)) (usr)->error(usr, "%s: ASSERT %s failed\n", __FUNCTION__, #x);
+
+#else
+
+#define ASSERT(usr, x)
+
+#endif
+
+#define FALSE 0
+#define TRUE 1
+
+typedef uint8_t BYTE;
+
+/* maximum number of codes in family */
+#define MAXNUMCODES 8
+
+/* model evolution, warning: only 1,3 and 5 allowed */
+#define DEFevol 3
+#define MINevol 0
+#define MAXevol 5
+
+/* starting wait mask index */
+#define DEFwmistart 0
+#define MINwmistart 0
+
+/* codeword length limit */
+#define DEFmaxclen 26
+
+/* target wait mask index */
+#define DEFwmimax 6
+
+/* number of symbols to encode before increasing wait mask index */
+#define DEFwminext 2048
+#define MINwminext 1
+#define MAXwminext 100000000
+
+typedef struct QuicFamily {
+    unsigned int nGRcodewords[MAXNUMCODES];      /* indexed by code number, contains number of
+                                                    unmodofied GR codewords in the code */
+    unsigned int notGRcwlen[MAXNUMCODES];        /* indexed by code number, contains codeword
+                                                    length of the not-GR codeword */
+    unsigned int notGRprefixmask[MAXNUMCODES];   /* indexed by code number, contains mask to
+                                                    determine if the codeword is GR or not-GR */
+    unsigned int notGRsuffixlen[MAXNUMCODES];    /* indexed by code number, contains suffix
+                                                    length of the not-GR codeword */
+
+    /* array for translating distribution U to L for depths up to 8 bpp,
+    initialized by decorelateinit() */
+    BYTE xlatU2L[256];
+
+    /* array for translating distribution L to U for depths up to 8 bpp,
+       initialized by corelateinit() */
+    unsigned int xlatL2U[256];
+} QuicFamily;
+
+static QuicFamily family_8bpc;
+static QuicFamily family_5bpc;
+
+typedef unsigned COUNTER;   /* counter in the array of counters in bucket of the data model */
+
+typedef struct s_bucket {
+    COUNTER *pcounters;     /* pointer to array of counters */
+    unsigned int bestcode;  /* best code so far */
+} s_bucket;
+
+typedef struct Encoder Encoder;
+
+typedef struct CommonState {
+    Encoder *encoder;
+
+    unsigned int waitcnt;
+    unsigned int tabrand_seed;
+    unsigned int wm_trigger;
+    unsigned int wmidx;
+    unsigned int wmileft;
+
+#ifdef RLE_STAT
+    int melcstate; /* index to the state array */
+
+    int melclen;  /* contents of the state array location
+                     indexed by melcstate: the "expected"
+                     run length is 2^melclen, shorter runs are
+                     encoded by a 1 followed by the run length
+                     in binary representation, wit a fixed length
+                     of melclen bits */
+
+    unsigned long melcorder;  /* 2^ melclen */
+#endif
+} CommonState;
+
+
+#define MAX_CHANNELS 4
+
+typedef struct FamilyStat {
+    s_bucket **buckets_ptrs;
+    s_bucket *buckets_buf;
+    COUNTER *counters;
+} FamilyStat;
+
+typedef struct Channel {
+    Encoder *encoder;
+
+    int correlate_row_width;
+    BYTE *correlate_row;
+
+    s_bucket **_buckets_ptrs;
+
+    FamilyStat family_stat_8bpc;
+    FamilyStat family_stat_5bpc;
+
+    CommonState state;
+} Channel;
+
+struct Encoder {
+    QuicUsrContext *usr;
+    QuicImageType type;
+    unsigned int width;
+    unsigned int height;
+    unsigned int num_channels;
+
+    unsigned int n_buckets_8bpc;
+    unsigned int n_buckets_5bpc;
+
+    unsigned int io_available_bits;
+    uint32_t io_word;
+    uint32_t io_next_word;
+    uint32_t *io_now;
+    uint32_t *io_end;
+    uint32_t io_words_count;
+
+    int rows_completed;
+
+    Channel channels[MAX_CHANNELS];
+
+    CommonState rgb_state;
+};
+
+/* target wait mask index */
+static int wmimax = DEFwmimax;
+
+/* number of symbols to encode before increasing wait mask index */
+static int wminext = DEFwminext;
+
+/* model evolution mode */
+static int evol = DEFevol;
+
+/* bppmask[i] contains i ones as lsb-s */
+static const unsigned long int bppmask[33] = {
+    0x00000000, /* [0] */
+    0x00000001, 0x00000003, 0x00000007, 0x0000000f,
+    0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
+    0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
+    0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
+    0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
+    0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
+    0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
+    0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff /* [32] */
+};
+
+static const unsigned int bitat[32] = {
+    0x00000001, 0x00000002, 0x00000004, 0x00000008,
+    0x00000010, 0x00000020, 0x00000040, 0x00000080,
+    0x00000100, 0x00000200, 0x00000400, 0x00000800,
+    0x00001000, 0x00002000, 0x00004000, 0x00008000,
+    0x00010000, 0x00020000, 0x00040000, 0x00080000,
+    0x00100000, 0x00200000, 0x00400000, 0x00800000,
+    0x01000000, 0x02000000, 0x04000000, 0x08000000,
+    0x10000000, 0x20000000, 0x40000000, 0x80000000 /* [31]*/
+};
+
+
+#define TABRAND_TABSIZE 256
+#define TABRAND_SEEDMASK 0x0ff
+
+static const unsigned int tabrand_chaos[TABRAND_TABSIZE] = {
+    0x02c57542, 0x35427717, 0x2f5a2153, 0x9244f155, 0x7bd26d07, 0x354c6052, 0x57329b28, 0x2993868e,
+    0x6cd8808c, 0x147b46e0, 0x99db66af, 0xe32b4cac, 0x1b671264, 0x9d433486, 0x62a4c192, 0x06089a4b,
+    0x9e3dce44, 0xdaabee13, 0x222425ea, 0xa46f331d, 0xcd589250, 0x8bb81d7f, 0xc8b736b9, 0x35948d33,
+    0xd7ac7fd0, 0x5fbe2803, 0x2cfbc105, 0x013dbc4e, 0x7a37820f, 0x39f88e9e, 0xedd58794, 0xc5076689,
+    0xfcada5a4, 0x64c2f46d, 0xb3ba3243, 0x8974b4f9, 0x5a05aebd, 0x20afcd00, 0x39e2b008, 0x88a18a45,
+    0x600bde29, 0xf3971ace, 0xf37b0a6b, 0x7041495b, 0x70b707ab, 0x06beffbb, 0x4206051f, 0xe13c4ee3,
+    0xc1a78327, 0x91aa067c, 0x8295f72a, 0x732917a6, 0x1d871b4d, 0x4048f136, 0xf1840e7e, 0x6a6048c1,
+    0x696cb71a, 0x7ff501c3, 0x0fc6310b, 0x57e0f83d, 0x8cc26e74, 0x11a525a2, 0x946934c7, 0x7cd888f0,
+    0x8f9d8604, 0x4f86e73b, 0x04520316, 0xdeeea20c, 0xf1def496, 0x67687288, 0xf540c5b2, 0x22401484,
+    0x3478658a, 0xc2385746, 0x01979c2c, 0x5dad73c8, 0x0321f58b, 0xf0fedbee, 0x92826ddf, 0x284bec73,
+    0x5b1a1975, 0x03df1e11, 0x20963e01, 0xa17cf12b, 0x740d776e, 0xa7a6bf3c, 0x01b5cce4, 0x1118aa76,
+    0xfc6fac0a, 0xce927e9b, 0x00bf2567, 0x806f216c, 0xbca69056, 0x795bd3e9, 0xc9dc4557, 0x8929b6c2,
+    0x789d52ec, 0x3f3fbf40, 0xb9197368, 0xa38c15b5, 0xc3b44fa8, 0xca8333b0, 0xb7e8d590, 0xbe807feb,
+    0xbf5f8360, 0xd99e2f5c, 0x372928e1, 0x7c757c4c, 0x0db5b154, 0xc01ede02, 0x1fc86e78, 0x1f3985be,
+    0xb4805c77, 0x00c880fa, 0x974c1b12, 0x35ab0214, 0xb2dc840d, 0x5b00ae37, 0xd313b026, 0xb260969d,
+    0x7f4c8879, 0x1734c4d3, 0x49068631, 0xb9f6a021, 0x6b863e6f, 0xcee5debf, 0x29f8c9fb, 0x53dd6880,
+    0x72b61223, 0x1f67a9fd, 0x0a0f6993, 0x13e59119, 0x11cca12e, 0xfe6b6766, 0x16b6effc, 0x97918fc4,
+    0xc2b8a563, 0x94f2f741, 0x0bfa8c9a, 0xd1537ae8, 0xc1da349c, 0x873c60ca, 0x95005b85, 0x9b5c080e,
+    0xbc8abbd9, 0xe1eab1d2, 0x6dac9070, 0x4ea9ebf1, 0xe0cf30d4, 0x1ef5bd7b, 0xd161043e, 0x5d2fa2e2,
+    0xff5d3cae, 0x86ed9f87, 0x2aa1daa1, 0xbd731a34, 0x9e8f4b22, 0xb1c2c67a, 0xc21758c9, 0xa182215d,
+    0xccb01948, 0x8d168df7, 0x04238cfe, 0x368c3dbc, 0x0aeadca5, 0xbad21c24, 0x0a71fee5, 0x9fc5d872,
+    0x54c152c6, 0xfc329483, 0x6783384a, 0xeddb3e1c, 0x65f90e30, 0x884ad098, 0xce81675a, 0x4b372f7d,
+    0x68bf9a39, 0x43445f1e, 0x40f8d8cb, 0x90d5acb6, 0x4cd07282, 0x349eeb06, 0x0c9d5332, 0x520b24ef,
+    0x80020447, 0x67976491, 0x2f931ca3, 0xfe9b0535, 0xfcd30220, 0x61a9e6cc, 0xa487d8d7, 0x3f7c5dd1,
+    0x7d0127c5, 0x48f51d15, 0x60dea871, 0xc9a91cb7, 0x58b53bb3, 0x9d5e0b2d, 0x624a78b4, 0x30dbee1b,
+    0x9bdf22e7, 0x1df5c299, 0x2d5643a7, 0xf4dd35ff, 0x03ca8fd6, 0x53b47ed8, 0x6f2c19aa, 0xfeb0c1f4,
+    0x49e54438, 0x2f2577e6, 0xbf876969, 0x72440ea9, 0xfa0bafb8, 0x74f5b3a0, 0x7dd357cd, 0x89ce1358,
+    0x6ef2cdda, 0x1e7767f3, 0xa6be9fdb, 0x4f5f88f8, 0xba994a3a, 0x08ca6b65, 0xe0893818, 0x9e00a16a,
+    0xf42bfc8f, 0x9972eedc, 0x749c8b51, 0x32c05f5e, 0xd706805f, 0x6bfbb7cf, 0xd9210a10, 0x31a1db97,
+    0x923a9559, 0x37a7a1f6, 0x059f8861, 0xca493e62, 0x65157e81, 0x8f6467dd, 0xab85ff9f, 0x9331aff2,
+    0x8616b9f5, 0xedbd5695, 0xee7e29b1, 0x313ac44f, 0xb903112f, 0x432ef649, 0xdc0a36c0, 0x61cf2bba,
+    0x81474925, 0xa8b6c7ad, 0xee5931de, 0xb2f8158d, 0x59fb7409, 0x2e3dfaed, 0x9af25a3f, 0xe1fed4d5,
+};
+
+static unsigned int stabrand()
+{
+    //ASSERT( !(TABRAND_SEEDMASK & TABRAND_TABSIZE));
+    //ASSERT( TABRAND_SEEDMASK + 1 == TABRAND_TABSIZE );
+
+    return TABRAND_SEEDMASK;
+}
+
+static unsigned int tabrand(unsigned int *tabrand_seed)
+{
+    return tabrand_chaos[++*tabrand_seed & TABRAND_SEEDMASK];
+}
+
+static const unsigned short besttrigtab[3][11] = { /* array of wm_trigger for waitmask and evol,
+                                                    used by set_wm_trigger() */
+    /* 1 */ { 550, 900, 800, 700, 500, 350, 300, 200, 180, 180, 160},
+    /* 3 */ { 110, 550, 900, 800, 550, 400, 350, 250, 140, 160, 140},
+    /* 5 */ { 100, 120, 550, 900, 700, 500, 400, 300, 220, 250, 160}
+};
+
+/* set wm_trigger knowing waitmask (param) and evol (glob)*/
+static void set_wm_trigger(CommonState *state)
+{
+    unsigned int wm = state->wmidx;
+    if (wm > 10) {
+        wm = 10;
+    }
+
+    ASSERT(state->encoder->usr, evol < 6);
+
+    state->wm_trigger = besttrigtab[evol / 2][wm];
+
+    ASSERT(state->encoder->usr, state->wm_trigger <= 2000);
+    ASSERT(state->encoder->usr, state->wm_trigger >= 1);
+}
+
+static int ceil_log_2(int val) /* ceil(log_2(val)) */
+{
+    int result;
+
+    //ASSERT(val>0);
+
+    if (val == 1) {
+        return 0;
+    }
+
+    result = 1;
+    val -= 1;
+    while (val >>= 1) {
+        result++;
+    }
+
+    return result;
+}
+
+/* number of leading zeroes in the byte, used by cntlzeroes(uint)*/
+static const BYTE lzeroes[256] = {
+    8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* count leading zeroes */
+static unsigned int cnt_l_zeroes(const unsigned int bits)
+{
+    if (bits & 0xff800000) {
+        return lzeroes[bits >> 24];
+    } else if (bits & 0xffff8000) {
+        return 8 + lzeroes[(bits >> 16) & 0x000000ff];
+    } else if (bits & 0xffffff80) {
+        return 16 + lzeroes[(bits >> 8) & 0x000000ff];
+    } else {
+        return 24 + lzeroes[bits & 0x000000ff];
+    }
+}
+
+#define QUIC_FAMILY_8BPC
+#include "quic_family_tmpl.c"
+
+#ifdef QUIC_RGB
+#define QUIC_FAMILY_5BPC
+#include "quic_family_tmpl.c"
+#endif
+
+static void decorelate_init(QuicFamily *family, int bpc)
+{
+    const unsigned int pixelbitmask = bppmask[bpc];
+    const unsigned int pixelbitmaskshr = pixelbitmask >> 1;
+    unsigned int s;
+
+    //ASSERT(bpc <= 8);
+
+    for (s = 0; s <= pixelbitmask; s++) {
+        if (s <= pixelbitmaskshr) {
+            family->xlatU2L[s] = s << 1;
+        } else {
+            family->xlatU2L[s] = ((pixelbitmask - s) << 1) + 1;
+        }
+    }
+}
+
+static void corelate_init(QuicFamily *family, int bpc)
+{
+    const unsigned long int pixelbitmask = bppmask[bpc];
+    unsigned long int s;
+
+    //ASSERT(bpc <= 8);
+
+    for (s = 0; s <= pixelbitmask; s++) {
+        if (s & 0x01) {
+            family->xlatL2U[s] = pixelbitmask - (s >> 1);
+        } else {
+            family->xlatL2U[s] = (s >> 1);
+        }
+    }
+}
+
+static void family_init(QuicFamily *family, int bpc, int limit)
+{
+    int l;
+
+    for (l = 0; l < bpc; l++) { /* fill arrays indexed by code number */
+        int altprefixlen, altcodewords;
+
+        altprefixlen = limit - bpc;
+        if (altprefixlen > (int)(bppmask[bpc - l])) {
+            altprefixlen = bppmask[bpc - l];
+        }
+
+        altcodewords = bppmask[bpc] + 1 - (altprefixlen << l);
+
+        family->nGRcodewords[l] = (altprefixlen << l);
+        family->notGRcwlen[l] = altprefixlen + ceil_log_2(altcodewords);
+        family->notGRprefixmask[l] = bppmask[32 - altprefixlen]; /* needed for decoding only */
+        family->notGRsuffixlen[l] = ceil_log_2(altcodewords); /* needed for decoding only */
+    }
+
+    decorelate_init(family, bpc);
+    corelate_init(family, bpc);
+}
+
+static void more_io_words(Encoder *encoder)
+{
+    uint32_t *io_ptr;
+    int num_io_words = encoder->usr->more_space(encoder->usr, &io_ptr, encoder->rows_completed);
+    if (num_io_words <= 0) {
+        encoder->usr->error(encoder->usr, "%s: no more words\n", __FUNCTION__);
+    }
+    ASSERT(encoder->usr, io_ptr);
+    encoder->io_words_count += num_io_words;
+    encoder->io_now = io_ptr;
+    encoder->io_end = encoder->io_now + num_io_words;
+}
+
+static void __write_io_word(Encoder *encoder)
+{
+    more_io_words(encoder);
+    *(encoder->io_now++) = encoder->io_word;
+}
+
+static void (*__write_io_word_ptr)(Encoder *encoder) = __write_io_word;
+
+static INLINE void write_io_word(Encoder *encoder)
+{
+    if (encoder->io_now == encoder->io_end) {
+        __write_io_word_ptr(encoder); //disable inline optimizations
+        return;
+    }
+    *(encoder->io_now++) = encoder->io_word;
+}
+
+static INLINE void encode(Encoder *encoder, unsigned int word, unsigned int len)
+{
+    int delta;
+
+    ASSERT(encoder->usr, len > 0 && len < 32);
+    ASSERT(encoder->usr, !(word & ~bppmask[len]));
+    if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
+        encoder->io_available_bits = delta;
+        encoder->io_word |= word << encoder->io_available_bits;
+        return;
+    }
+    delta = -delta;
+    encoder->io_word |= word >> delta;
+    write_io_word(encoder);
+    encoder->io_available_bits = 32 - delta;
+    encoder->io_word = word << encoder->io_available_bits;
+
+    ASSERT(encoder->usr, encoder->io_available_bits < 32);
+    ASSERT(encoder->usr, (encoder->io_word & bppmask[encoder->io_available_bits]) == 0);
+}
+
+static INLINE void encode_32(Encoder *encoder, unsigned int word)
+{
+    encode(encoder, word >> 16, 16);
+    encode(encoder, word & 0x0000ffff, 16);
+}
+
+static INLINE void flush(Encoder *encoder)
+{
+    if (encoder->io_available_bits > 0 && encoder->io_available_bits != 32) {
+        encode(encoder, 0, encoder->io_available_bits);
+    }
+    encode_32(encoder, 0);
+    encode(encoder, 0, 1);
+}
+
+static void __read_io_word(Encoder *encoder)
+{
+    more_io_words(encoder);
+    encoder->io_next_word = *(encoder->io_now++);
+}
+
+static void (*__read_io_word_ptr)(Encoder *encoder) = __read_io_word;
+
+
+static INLINE void read_io_word(Encoder *encoder)
+{
+    if (encoder->io_now == encoder->io_end) {
+        __read_io_word_ptr(encoder); //disable inline optimizations
+        return;
+    }
+    ASSERT(encoder->usr, encoder->io_now < encoder->io_end);
+    encoder->io_next_word = *(encoder->io_now++);
+}
+
+static INLINE void decode_eatbits(Encoder *encoder, int len)
+{
+    int delta;
+
+    ASSERT(encoder->usr, len > 0 && len < 32);
+    encoder->io_word <<= len;
+
+    if ((delta = ((int)encoder->io_available_bits - len)) >= 0) {
+        encoder->io_available_bits = delta;
+        encoder->io_word |= encoder->io_next_word >> encoder->io_available_bits;
+        return;
+    }
+
+    delta = -delta;
+    encoder->io_word |= encoder->io_next_word << delta;
+    read_io_word(encoder);
+    encoder->io_available_bits = 32 - delta;
+    encoder->io_word |= (encoder->io_next_word >> encoder->io_available_bits);
+}
+
+static INLINE void decode_eat32bits(Encoder *encoder)
+{
+    decode_eatbits(encoder, 16);
+    decode_eatbits(encoder, 16);
+}
+
+#ifdef RLE
+
+#ifdef RLE_STAT
+
+static INLINE void encode_ones(Encoder *encoder, unsigned int n)
+{
+    unsigned int count;
+
+    for (count = n >> 5; count; count--) {
+        encode(encoder, ~0U, 32);
+    }
+
+    if ((n &= 0x1f)) {
+        encode(encoder, (1U << n) - 1, n);
+    }
+}
+
+#define MELCSTATES 32 /* number of melcode states */
+
+static int zeroLUT[256]; /* table to find out number of leading zeros */
+
+static int J[MELCSTATES] = {
+    0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7,
+    7, 8, 9, 10, 11, 12, 13, 14, 15
+};
+
+/* creates the bit counting look-up table. */
+static void init_zeroLUT()
+{
+    int i, j, k, l;
+
+    j = k = 1;
+    l = 8;
+    for (i = 0; i < 256; ++i) {
+        zeroLUT[i] = l;
+        --k;
+        if (k == 0) {
+            k = j;
+            --l;
+            j *= 2;
+        }
+    }
+}
+
+static void encoder_init_rle(CommonState *state)
+{
+    state->melcstate = 0;
+    state->melclen = J[0];
+    state->melcorder = 1 << state->melclen;
+}
+
+#ifdef QUIC_RGB
+
+static void encode_run(Encoder *encoder, unsigned int runlen) //todo: try use end of line
+{
+    int hits = 0;
+
+    while (runlen >= encoder->rgb_state.melcorder) {
+        hits++;
+        runlen -= encoder->rgb_state.melcorder;
+        if (encoder->rgb_state.melcstate < MELCSTATES) {
+            encoder->rgb_state.melclen = J[++encoder->rgb_state.melcstate];
+            encoder->rgb_state.melcorder = (1L << encoder->rgb_state.melclen);
+        }
+    }
+
+    /* send the required number of "hit" bits (one per occurrence
+       of a run of length melcorder). This number is never too big:
+       after 31 such "hit" bits, each "hit" would represent a run of 32K
+       pixels.
+    */
+    encode_ones(encoder, hits);
+
+    encode(encoder, runlen, encoder->rgb_state.melclen + 1);
+
+    /* adjust melcoder parameters */
+    if (encoder->rgb_state.melcstate) {
+        encoder->rgb_state.melclen = J[--encoder->rgb_state.melcstate];
+        encoder->rgb_state.melcorder = (1L << encoder->rgb_state.melclen);
+    }
+}
+
+#endif
+
+static void encode_channel_run(Encoder *encoder, Channel *channel, unsigned int runlen)
+{
+    //todo: try use end of line
+    int hits = 0;
+
+    while (runlen >= channel->state.melcorder) {
+        hits++;
+        runlen -= channel->state.melcorder;
+        if (channel->state.melcstate < MELCSTATES) {
+            channel->state.melclen = J[++channel->state.melcstate];
+            channel->state.melcorder = (1L << channel->state.melclen);
+        }
+    }
+
+    /* send the required number of "hit" bits (one per occurrence
+       of a run of length melcorder). This number is never too big:
+       after 31 such "hit" bits, each "hit" would represent a run of 32K
+       pixels.
+    */
+    encode_ones(encoder, hits);
+
+    encode(encoder, runlen, channel->state.melclen + 1);
+
+    /* adjust melcoder parameters */
+    if (channel->state.melcstate) {
+        channel->state.melclen = J[--channel->state.melcstate];
+        channel->state.melcorder = (1L << channel->state.melclen);
+    }
+}
+
+/* decoding routine: reads bits from the input and returns a run length. */
+/* argument is the number of pixels left to end-of-line (bound on run length) */
+
+#ifdef QUIC_RGB
+static int decode_run(Encoder *encoder)
+{
+    int runlen = 0;
+
+    do {
+        register int temp, hits;
+        temp = zeroLUT[(BYTE)(~(encoder->io_word >> 24))];/* number of leading ones in the
+                                                                      input stream, up to 8 */
+        for (hits = 1; hits <= temp; hits++) {
+            runlen += encoder->rgb_state.melcorder;
+
+            if (encoder->rgb_state.melcstate < MELCSTATES) {
+                encoder->rgb_state.melclen = J[++encoder->rgb_state.melcstate];
+                encoder->rgb_state.melcorder = (1U << encoder->rgb_state.melclen);
+            }
+        }
+        if (temp != 8) {
+            decode_eatbits(encoder, temp + 1);  /* consume the leading
+                                                            0 of the remainder encoding */
+            break;
+        }
+        decode_eatbits(encoder, 8);
+    } while (1);
+
+    /* read the length of the remainder */
+    if (encoder->rgb_state.melclen) {
+        runlen += encoder->io_word >> (32 - encoder->rgb_state.melclen);
+        decode_eatbits(encoder, encoder->rgb_state.melclen);
+    }
+
+    /* adjust melcoder parameters */
+    if (encoder->rgb_state.melcstate) {
+        encoder->rgb_state.melclen = J[--encoder->rgb_state.melcstate];
+        encoder->rgb_state.melcorder = (1U << encoder->rgb_state.melclen);
+    }
+
+    return runlen;
+}
+
+#endif
+
+static int decode_channel_run(Encoder *encoder, Channel *channel)
+{
+    int runlen = 0;
+
+    do {
+        register int temp, hits;
+        temp = zeroLUT[(BYTE)(~(encoder->io_word >> 24))];/* number of leading ones in the
+                                                                      input stream, up to 8 */
+        for (hits = 1; hits <= temp; hits++) {
+            runlen += channel->state.melcorder;
+
+            if (channel->state.melcstate < MELCSTATES) {
+                channel->state.melclen = J[++channel->state.melcstate];
+                channel->state.melcorder = (1U << channel->state.melclen);
+            }
+        }
+        if (temp != 8) {
+            decode_eatbits(encoder, temp + 1);  /* consume the leading
+                                                            0 of the remainder encoding */
+            break;
+        }
+        decode_eatbits(encoder, 8);
+    } while (1);
+
+    /* read the length of the remainder */
+    if (channel->state.melclen) {
+        runlen += encoder->io_word >> (32 - channel->state.melclen);
+        decode_eatbits(encoder, channel->state.melclen);
+    }
+
+    /* adjust melcoder parameters */
+    if (channel->state.melcstate) {
+        channel->state.melclen = J[--channel->state.melcstate];
+        channel->state.melcorder = (1U << channel->state.melclen);
+    }
+
+    return runlen;
+}
+
+#else
+
+static INLINE int find_msb(int x)
+{
+    int r;
+
+    __asm__("bsrl %1,%0\n\t"
+            "jnz 1f\n\t"
+            "movl $-1,%0\n"
+            "1:" : "=r" (r) : "rm" (x));
+    return r + 1;
+}
+
+static INLINE void encode_run(Encoder *encoder, unsigned int len)
+{
+    int odd = len & 1U;
+    int msb;
+
+    len &= ~1U;
+
+    while ((msb = find_msb(len))) {
+        len &= ~(1 << (msb - 1));
+        ASSERT(encoder->usr, msb < 32);
+        encode(encoder, (1 << (msb)) - 1, msb);
+        encode(encoder, 0, 1);
+    }
+
+    if (odd) {
+        encode(encoder, 2, 2);
+    } else {
+        encode(encoder, 0, 1);
+    }
+}
+
+static INLINE unsigned int decode_run(Encoder *encoder)
+{
+    unsigned int len = 0;
+    int count;
+
+    do {
+        count = 0;
+        while (encoder->io_word & (1U << 31)) {
+            decode_eatbits(encoder, 1);
+            count++;
+            ASSERT(encoder->usr, count < 32);
+        }
+        decode_eatbits(encoder, 1);
+        len += (1U << count) >> 1;
+    } while (count > 1);
+
+    return len;
+}
+
+#endif
+#endif
+
+static INLINE void init_decode_io(Encoder *encoder)
+{
+    encoder->io_next_word = encoder->io_word = *(encoder->io_now++);
+    encoder->io_available_bits = 0;
+}
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#define ATTR_PACKED
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+typedef struct ATTR_PACKED one_byte_pixel_t {
+    BYTE a;
+} one_byte_t;
+
+typedef struct ATTR_PACKED three_bytes_pixel_t {
+    BYTE a;
+    BYTE b;
+    BYTE c;
+} three_bytes_t;
+
+typedef struct ATTR_PACKED four_bytes_pixel_t {
+    BYTE a;
+    BYTE b;
+    BYTE c;
+    BYTE d;
+} four_bytes_t;
+
+typedef struct ATTR_PACKED rgb32_pixel_t {
+    BYTE b;
+    BYTE g;
+    BYTE r;
+    BYTE pad;
+} rgb32_pixel_t;
+
+typedef struct ATTR_PACKED rgb24_pixel_t {
+    BYTE b;
+    BYTE g;
+    BYTE r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#define ONE_BYTE
+#include "quic_tmpl.c"
+
+#define FOUR_BYTE
+#include "quic_tmpl.c"
+
+#ifdef QUIC_RGB
+
+#define QUIC_RGB32
+#include "quic_rgb_tmpl.c"
+
+#define QUIC_RGB24
+#include "quic_rgb_tmpl.c"
+
+#define QUIC_RGB16
+#include "quic_rgb_tmpl.c"
+
+#define QUIC_RGB16_TO_32
+#include "quic_rgb_tmpl.c"
+
+#else
+
+#define THREE_BYTE
+#include "quic_tmpl.c"
+
+#endif
+
+static void fill_model_structures(Encoder *encoder, FamilyStat *family_stat,
+                                  unsigned int rep_first, unsigned int first_size,
+                                  unsigned int rep_next, unsigned int mul_size,
+                                  unsigned int levels, unsigned int ncounters,
+                                  unsigned int nbuckets, unsigned int n_buckets_ptrs)
+{
+    unsigned int
+    bsize,
+    bstart,
+    bend = 0,
+    repcntr,
+    bnumber;
+
+    COUNTER * free_counter = family_stat->counters;/* first free location in the array of
+                                                      counters */
+
+    bnumber = 0;
+
+    repcntr = rep_first + 1;    /* first bucket */
+    bsize = first_size;
+
+    do { /* others */
+        if (bnumber) {
+            bstart = bend + 1;
+        } else {
+            bstart = 0;
+        }
+
+        if (!--repcntr) {
+            repcntr = rep_next;
+            bsize *= mul_size;
+        }
+
+        bend = bstart + bsize - 1;
+        if (bend + bsize >= levels) {
+            bend = levels - 1;
+        }
+
+        family_stat->buckets_buf[bnumber].pcounters = free_counter;
+        free_counter += ncounters;
+
+        ASSERT(encoder->usr, bstart < n_buckets_ptrs);
+        {
+            unsigned int i;
+            ASSERT(encoder->usr, bend < n_buckets_ptrs);
+            for (i = bstart; i <= bend; i++) {
+                family_stat->buckets_ptrs[i] = family_stat->buckets_buf + bnumber;
+            }
+        }
+
+        bnumber++;
+    } while (bend < levels - 1);
+
+    ASSERT(encoder->usr, free_counter - family_stat->counters == nbuckets * ncounters);
+}
+
+static void find_model_params(Encoder *encoder,
+                              const int bpc,
+                              unsigned int *ncounters,
+                              unsigned int *levels,
+                              unsigned int *n_buckets_ptrs,
+                              unsigned int *repfirst,
+                              unsigned int *firstsize,
+                              unsigned int *repnext,
+                              unsigned int *mulsize,
+                              unsigned int *nbuckets)
+{
+    unsigned int bsize;              /* bucket size */
+    unsigned int bstart, bend = 0;   /* bucket start and end, range : 0 to levels-1*/
+    unsigned int repcntr;            /* helper */
+
+    ASSERT(encoder->usr, bpc <= 8 && bpc > 0);
+
+
+    *ncounters = 8;
+
+    *levels = 0x1 << bpc;
+
+    *n_buckets_ptrs = 0;  /* ==0 means: not set yet */
+
+    switch (evol) {   /* set repfirst firstsize repnext mulsize */
+    case 1: /* buckets contain following numbers of contexts: 1 1 1 2 2 4 4 8 8 ... */
+        *repfirst = 3;
+        *firstsize = 1;
+        *repnext = 2;
+        *mulsize = 2;
+        break;
+    case 3: /* 1 2 4 8 16 32 64 ... */
+        *repfirst = 1;
+        *firstsize = 1;
+        *repnext = 1;
+        *mulsize = 2;
+        break;
+    case 5:                     /* 1 4 16 64 256 1024 4096 16384 65536 */
+        *repfirst = 1;
+        *firstsize = 1;
+        *repnext = 1;
+        *mulsize = 4;
+        break;
+    case 0: /* obsolete */
+    case 2: /* obsolete */
+    case 4: /* obsolete */
+        encoder->usr->error(encoder->usr, "findmodelparams(): evol value obsolete!!!\n");
+    default:
+        encoder->usr->error(encoder->usr, "findmodelparams(): evol out of range!!!\n");
+    }
+
+    *nbuckets = 0;
+    repcntr = *repfirst + 1;    /* first bucket */
+    bsize = *firstsize;
+
+    do { /* other buckets */
+        if (nbuckets) {         /* bucket start */
+            bstart = bend + 1;
+        } else {
+            bstart = 0;
+        }
+
+        if (!--repcntr) {         /* bucket size */
+            repcntr = *repnext;
+            bsize *= *mulsize;
+        }
+
+        bend = bstart + bsize - 1;  /* bucket end */
+        if (bend + bsize >= *levels) {  /* if following bucked was bigger than current one */
+            bend = *levels - 1;     /* concatenate them */
+        }
+
+        if (!*n_buckets_ptrs) {           /* array size not set yet? */
+            *n_buckets_ptrs = *levels;
+ #if 0
+            if (bend == *levels - 1) {   /* this bucket is last - all in the first array */
+                *n_buckets_ptrs = *levels;
+            } else if (bsize >= 256) { /* this bucket is allowed to reside in the 2nd table */
+                b_lo_ptrs = bstart;
+                assert(bstart);     /* previous bucket exists */
+            }
+ #endif
+        }
+
+        (*nbuckets)++;
+    } while (bend < *levels - 1);
+}
+
+static int init_model_structures(Encoder *encoder, FamilyStat *family_stat,
+                                 unsigned int rep_first, unsigned int first_size,
+                                 unsigned int rep_next, unsigned int mul_size,
+                                 unsigned int levels, unsigned int ncounters,
+                                 unsigned int n_buckets_ptrs, unsigned int n_buckets)
+{
+    family_stat->buckets_ptrs = (s_bucket **)encoder->usr->malloc(encoder->usr,
+                                                                  n_buckets_ptrs *
+                                                                  sizeof(s_bucket *));
+    if (!family_stat->buckets_ptrs) {
+        return FALSE;
+    }
+
+    family_stat->counters = (COUNTER *)encoder->usr->malloc(encoder->usr,
+                                                            n_buckets * sizeof(COUNTER) *
+                                                            MAXNUMCODES);
+    if (!family_stat->counters) {
+        goto error_1;
+    }
+
+    family_stat->buckets_buf = (s_bucket *)encoder->usr->malloc(encoder->usr,
+                                                                n_buckets * sizeof(s_bucket));
+    if (!family_stat->buckets_buf) {
+        goto error_2;
+    }
+
+    fill_model_structures(encoder, family_stat, rep_first, first_size, rep_next, mul_size, levels,
+                          ncounters, n_buckets, n_buckets_ptrs);
+
+    return TRUE;
+
+error_2:
+    encoder->usr->free(encoder->usr, family_stat->counters);
+
+error_1:
+    encoder->usr->free(encoder->usr, family_stat->buckets_ptrs);
+
+    return FALSE;
+}
+
+static void free_family_stat(QuicUsrContext *usr, FamilyStat *family_stat)
+{
+    usr->free(usr, family_stat->buckets_ptrs);
+    usr->free(usr, family_stat->counters);
+    usr->free(usr, family_stat->buckets_buf);
+}
+
+static int init_channel(Encoder *encoder, Channel *channel)
+{
+    unsigned int ncounters;
+    unsigned int levels;
+    unsigned int rep_first;
+    unsigned int first_size;
+    unsigned int rep_next;
+    unsigned int mul_size;
+    unsigned int n_buckets;
+    unsigned int n_buckets_ptrs;
+
+    channel->encoder = encoder;
+    channel->state.encoder = encoder;
+    channel->correlate_row_width = 0;
+    channel->correlate_row = NULL;
+
+    find_model_params(encoder, 8, &ncounters, &levels, &n_buckets_ptrs, &rep_first,
+                      &first_size, &rep_next, &mul_size, &n_buckets);
+    encoder->n_buckets_8bpc = n_buckets;
+    if (!init_model_structures(encoder, &channel->family_stat_8bpc, rep_first, first_size,
+                               rep_next, mul_size, levels, ncounters, n_buckets_ptrs,
+                               n_buckets)) {
+        return FALSE;
+    }
+
+    find_model_params(encoder, 5, &ncounters, &levels, &n_buckets_ptrs, &rep_first,
+                      &first_size, &rep_next, &mul_size, &n_buckets);
+    encoder->n_buckets_5bpc = n_buckets;
+    if (!init_model_structures(encoder, &channel->family_stat_5bpc, rep_first, first_size,
+                               rep_next, mul_size, levels, ncounters, n_buckets_ptrs,
+                               n_buckets)) {
+        free_family_stat(encoder->usr, &channel->family_stat_8bpc);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void destroy_channel(Channel *channel)
+{
+    QuicUsrContext *usr = channel->encoder->usr;
+    if (channel->correlate_row) {
+        usr->free(usr, channel->correlate_row - 1);
+    }
+    free_family_stat(usr, &channel->family_stat_8bpc);
+    free_family_stat(usr, &channel->family_stat_5bpc);
+}
+
+static int init_encoder(Encoder *encoder, QuicUsrContext *usr)
+{
+    int i;
+
+    encoder->usr = usr;
+    encoder->rgb_state.encoder = encoder;
+
+    for (i = 0; i < MAX_CHANNELS; i++) {
+        if (!init_channel(encoder, &encoder->channels[i])) {
+            for (--i; i >= 0; i--) {
+                destroy_channel(&encoder->channels[i]);
+            }
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+static int encoder_reste(Encoder *encoder, uint32_t *io_ptr, uint32_t *io_ptr_end)
+{
+    ASSERT(encoder->usr, ((unsigned long)io_ptr % 4) == ((unsigned long)io_ptr_end % 4));
+    ASSERT(encoder->usr, io_ptr <= io_ptr_end);
+
+    encoder->rgb_state.waitcnt = 0;
+    encoder->rgb_state.tabrand_seed = stabrand();
+    encoder->rgb_state.wmidx = DEFwmistart;
+    encoder->rgb_state.wmileft = wminext;
+    set_wm_trigger(&encoder->rgb_state);
+
+#if defined(RLE) && defined(RLE_STAT)
+    encoder_init_rle(&encoder->rgb_state);
+#endif
+
+    encoder->io_words_count = io_ptr_end - io_ptr;
+    encoder->io_now = io_ptr;
+    encoder->io_end = io_ptr_end;
+    encoder->rows_completed = 0;
+
+    return TRUE;
+}
+
+static int encoder_reste_channels(Encoder *encoder, int channels, int width, int bpc)
+{
+    int i;
+
+    encoder->num_channels = channels;
+
+    for (i = 0; i < channels; i++) {
+        s_bucket *bucket;
+        s_bucket *end_bucket;
+
+        if (encoder->channels[i].correlate_row_width < width) {
+            encoder->channels[i].correlate_row_width = 0;
+            if (encoder->channels[i].correlate_row) {
+                encoder->usr->free(encoder->usr, encoder->channels[i].correlate_row - 1);
+            }
+            if (!(encoder->channels[i].correlate_row = (BYTE *)encoder->usr->malloc(encoder->usr,
+                                                                                    width + 1))) {
+                return FALSE;
+            }
+            encoder->channels[i].correlate_row++;
+            encoder->channels[i].correlate_row_width = width;
+        }
+
+        if (bpc == 8) {
+            MEMCLEAR(encoder->channels[i].family_stat_8bpc.counters,
+                     encoder->n_buckets_8bpc * sizeof(COUNTER) * MAXNUMCODES);
+            bucket = encoder->channels[i].family_stat_8bpc.buckets_buf;
+            end_bucket = bucket + encoder->n_buckets_8bpc;
+            for (; bucket < end_bucket; bucket++) {
+                bucket->bestcode = /*BPC*/ 8 - 1;
+            }
+            encoder->channels[i]._buckets_ptrs = encoder->channels[i].family_stat_8bpc.buckets_ptrs;
+        } else if (bpc == 5) {
+            MEMCLEAR(encoder->channels[i].family_stat_5bpc.counters,
+                     encoder->n_buckets_5bpc * sizeof(COUNTER) * MAXNUMCODES);
+            bucket = encoder->channels[i].family_stat_5bpc.buckets_buf;
+            end_bucket = bucket + encoder->n_buckets_5bpc;
+            for (; bucket < end_bucket; bucket++) {
+                bucket->bestcode = /*BPC*/ 5 - 1;
+            }
+            encoder->channels[i]._buckets_ptrs = encoder->channels[i].family_stat_5bpc.buckets_ptrs;
+        } else {
+            encoder->usr->warn(encoder->usr, "%s: bad bpc %d\n", __FUNCTION__, bpc);
+            return FALSE;
+        }
+
+        encoder->channels[i].state.waitcnt = 0;
+        encoder->channels[i].state.tabrand_seed = stabrand();
+        encoder->channels[i].state.wmidx = DEFwmistart;
+        encoder->channels[i].state.wmileft = wminext;
+        set_wm_trigger(&encoder->channels[i].state);
+
+#if defined(RLE) && defined(RLE_STAT)
+        encoder_init_rle(&encoder->channels[i].state);
+#endif
+    }
+    return TRUE;
+}
+
+static void quic_image_params(Encoder *encoder, QuicImageType type, int *channels, int *bpc)
+{
+    ASSERT(encoder->usr, channels && bpc);
+    switch (type) {
+    case QUIC_IMAGE_TYPE_GRAY:
+        *channels = 1;
+        *bpc = 8;
+        break;
+    case QUIC_IMAGE_TYPE_RGB16:
+        *channels = 3;
+        *bpc = 5;
+#ifndef QUIC_RGB
+        encoder->usr->error(encoder->usr, "not implemented\n");
+#endif
+        break;
+    case QUIC_IMAGE_TYPE_RGB24:
+        *channels = 3;
+        *bpc = 8;
+        break;
+    case QUIC_IMAGE_TYPE_RGB32:
+        *channels = 3;
+        *bpc = 8;
+        break;
+    case QUIC_IMAGE_TYPE_RGBA:
+        *channels = 4;
+        *bpc = 8;
+        break;
+    case QUIC_IMAGE_TYPE_INVALID:
+    default:
+        *channels = 0;
+        *bpc = 0;
+        encoder->usr->error(encoder->usr, "bad image type\n");
+    }
+}
+
+#define FILL_LINES() {                                                  \
+    if (line == lines_end) {                                            \
+        int n = encoder->usr->more_lines(encoder->usr, &line);          \
+        if (n <= 0) {                                                   \
+            encoder->usr->error(encoder->usr, "more lines failed\n");   \
+        }                                                               \
+        lines_end = line + n * stride;                                  \
+    }                                                                   \
+}
+
+#define NEXT_LINE() {       \
+    line += stride;         \
+    FILL_LINES();           \
+}
+
+#define QUIC_COMPRESS_RGB(bits)                                                                 \
+        encoder->channels[0].correlate_row[-1] = 0;                                             \
+        encoder->channels[1].correlate_row[-1] = 0;                                             \
+        encoder->channels[2].correlate_row[-1] = 0;                                             \
+        quic_rgb##bits##_compress_row0(encoder, (rgb##bits##_pixel_t *)(line), width);          \
+        encoder->rows_completed++;                                                              \
+        for (row = 1; row < height; row++) {                                                    \
+            prev = line;                                                                        \
+            NEXT_LINE();                                                                        \
+            encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];     \
+            encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];     \
+            encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];     \
+            quic_rgb##bits##_compress_row(encoder, (rgb##bits##_pixel_t *)prev,                 \
+                                          (rgb##bits##_pixel_t *)line, width);                  \
+            encoder->rows_completed++;                                                          \
+        }
+
+int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
+                uint8_t *line, unsigned int num_lines, int stride,
+                uint32_t *io_ptr, unsigned int num_io_words)
+{
+    Encoder *encoder = (Encoder *)quic;
+    uint32_t *io_ptr_end = io_ptr + num_io_words;
+    uint8_t *lines_end;
+    int row;
+    uint8_t *prev;
+    int channels;
+    int bpc;
+#ifndef QUIC_RGB
+    int i;
+#endif
+
+    ASSERT(encoder->usr, line);
+    lines_end = line + num_lines * stride;
+
+    quic_image_params(encoder, type, &channels, &bpc);
+
+    if (!encoder_reste(encoder, io_ptr, io_ptr_end) ||
+        !encoder_reste_channels(encoder, channels, width, bpc)) {
+        return QUIC_ERROR;
+    }
+
+    encoder->io_word = 0;
+    encoder->io_available_bits = 32;
+
+    encode_32(encoder, QUIC_MAGIC);
+    encode_32(encoder, QUIC_VERSION);
+    encode_32(encoder, type);
+    encode_32(encoder, width);
+    encode_32(encoder, height);
+
+    FILL_LINES();
+
+    switch (type) {
+#ifdef QUIC_RGB
+    case QUIC_IMAGE_TYPE_RGB32:
+        ASSERT(encoder->usr, ABS(stride) >= width * 4);
+        QUIC_COMPRESS_RGB(32);
+        break;
+    case QUIC_IMAGE_TYPE_RGB24:
+        ASSERT(encoder->usr, ABS(stride) >= width * 3);
+        QUIC_COMPRESS_RGB(24);
+        break;
+    case QUIC_IMAGE_TYPE_RGB16:
+        ASSERT(encoder->usr, ABS(stride) >= width * 2);
+        QUIC_COMPRESS_RGB(16);
+        break;
+    case QUIC_IMAGE_TYPE_RGBA:
+        ASSERT(encoder->usr, ABS(stride) >= width * 4);
+
+        encoder->channels[0].correlate_row[-1] = 0;
+        encoder->channels[1].correlate_row[-1] = 0;
+        encoder->channels[2].correlate_row[-1] = 0;
+        quic_rgb32_compress_row0(encoder, (rgb32_pixel_t *)(line), width);
+
+        encoder->channels[3].correlate_row[-1] = 0;
+        quic_four_compress_row0(encoder, &encoder->channels[3], (four_bytes_t *)(line + 3), width);
+
+        encoder->rows_completed++;
+
+        for (row = 1; row < height; row++) {
+            prev = line;
+            NEXT_LINE();
+            encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
+            encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];
+            encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];
+            quic_rgb32_compress_row(encoder, (rgb32_pixel_t *)prev, (rgb32_pixel_t *)line, width);
+
+            encoder->channels[3].correlate_row[-1] = encoder->channels[3].correlate_row[0];
+            quic_four_compress_row(encoder, &encoder->channels[3], (four_bytes_t *)(prev + 3),
+                                   (four_bytes_t *)(line + 3), width);
+            encoder->rows_completed++;
+        }
+        break;
+#else
+    case QUIC_IMAGE_TYPE_RGB24:
+        ASSERT(encoder->usr, ABS(stride) >= width * 3);
+        for (i = 0; i < 3; i++) {
+            encoder->channels[i].correlate_row[-1] = 0;
+            quic_three_compress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(line + i),
+                                     width);
+        }
+        encoder->rows_completed++;
+        for (row = 1; row < height; row++) {
+            prev = line;
+            NEXT_LINE();
+            for (i = 0; i < 3; i++) {
+                encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
+                quic_three_compress_row(encoder, &encoder->channels[i], (three_bytes_t *)(prev + i),
+                                        (three_bytes_t *)(line + i), width);
+            }
+            encoder->rows_completed++;
+        }
+        break;
+    case QUIC_IMAGE_TYPE_RGB32:
+    case QUIC_IMAGE_TYPE_RGBA:
+        ASSERT(encoder->usr, ABS(stride) >= width * 4);
+        for (i = 0; i < channels; i++) {
+            encoder->channels[i].correlate_row[-1] = 0;
+            quic_four_compress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(line + i),
+                                    width);
+        }
+        encoder->rows_completed++;
+        for (row = 1; row < height; row++) {
+            prev = line;
+            NEXT_LINE();
+            for (i = 0; i < channels; i++) {
+                encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
+                quic_four_compress_row(encoder, &encoder->channels[i], (four_bytes_t *)(prev + i),
+                                       (four_bytes_t *)(line + i), width);
+            }
+            encoder->rows_completed++;
+        }
+        break;
+#endif
+    case QUIC_IMAGE_TYPE_GRAY:
+        ASSERT(encoder->usr, ABS(stride) >= width);
+        encoder->channels[0].correlate_row[-1] = 0;
+        quic_one_compress_row0(encoder, &encoder->channels[0], (one_byte_t *)line, width);
+        encoder->rows_completed++;
+        for (row = 1; row < height; row++) {
+            prev = line;
+            NEXT_LINE();
+            encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
+            quic_one_compress_row(encoder, &encoder->channels[0], (one_byte_t *)prev,
+                                  (one_byte_t *)line, width);
+            encoder->rows_completed++;
+        }
+        break;
+    case QUIC_IMAGE_TYPE_INVALID:
+    default:
+        encoder->usr->error(encoder->usr, "bad image type\n");
+    }
+
+    flush(encoder);
+    encoder->io_words_count -= (encoder->io_end - encoder->io_now);
+
+    return encoder->io_words_count;
+}
+
+int quic_decode_begin(QuicContext *quic, uint32_t *io_ptr, unsigned int num_io_words,
+                      QuicImageType *out_type, int *out_width, int *out_height)
+{
+    Encoder *encoder = (Encoder *)quic;
+    uint32_t *io_ptr_end = io_ptr + num_io_words;
+    QuicImageType type;
+    int width;
+    int height;
+    uint32_t magic;
+    uint32_t version;
+    int channels;
+    int bpc;
+
+    if (!encoder_reste(encoder, io_ptr, io_ptr_end)) {
+        return QUIC_ERROR;
+    }
+
+    init_decode_io(encoder);
+
+    magic = encoder->io_word;
+    decode_eat32bits(encoder);
+    if (magic != QUIC_MAGIC) {
+        encoder->usr->warn(encoder->usr, "bad magic\n");
+        return QUIC_ERROR;
+    }
+
+    version = encoder->io_word;
+    decode_eat32bits(encoder);
+    if (version != QUIC_VERSION) {
+        encoder->usr->warn(encoder->usr, "bad version\n");
+        return QUIC_ERROR;
+    }
+
+    type = (QuicImageType)encoder->io_word;
+    decode_eat32bits(encoder);
+
+    width = encoder->io_word;
+    decode_eat32bits(encoder);
+
+    height = encoder->io_word;
+    decode_eat32bits(encoder);
+
+    quic_image_params(encoder, type, &channels, &bpc);
+
+    if (!encoder_reste_channels(encoder, channels, width, bpc)) {
+        return QUIC_ERROR;
+    }
+
+    *out_width = encoder->width = width;
+    *out_height = encoder->height = height;
+    *out_type = encoder->type = type;
+    return QUIC_OK;
+}
+
+#ifndef QUIC_RGB
+static void clear_row(four_bytes_t *row, int width)
+{
+    four_bytes_t *end;
+    for (end = row + width; row < end; row++) {
+        row->a = 0;
+    }
+}
+
+#endif
+
+#ifdef QUIC_RGB
+
+static void uncompress_rgba(Encoder *encoder, uint8_t *buf, int stride)
+{
+    unsigned int row;
+    uint8_t *prev;
+
+    encoder->channels[0].correlate_row[-1] = 0;
+    encoder->channels[1].correlate_row[-1] = 0;
+    encoder->channels[2].correlate_row[-1] = 0;
+    quic_rgb32_uncompress_row0(encoder, (rgb32_pixel_t *)buf, encoder->width);
+
+    encoder->channels[3].correlate_row[-1] = 0;
+    quic_four_uncompress_row0(encoder, &encoder->channels[3], (four_bytes_t *)(buf + 3),
+                              encoder->width);
+
+    encoder->rows_completed++;
+    for (row = 1; row < encoder->height; row++) {
+        prev = buf;
+        buf += stride;
+
+        encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
+        encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];
+        encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];
+        quic_rgb32_uncompress_row(encoder, (rgb32_pixel_t *)prev, (rgb32_pixel_t *)buf,
+                                  encoder->width);
+
+        encoder->channels[3].correlate_row[-1] = encoder->channels[3].correlate_row[0];
+        quic_four_uncompress_row(encoder, &encoder->channels[3], (four_bytes_t *)(prev + 3),
+                                 (four_bytes_t *)(buf + 3), encoder->width);
+
+        encoder->rows_completed++;
+    }
+}
+
+#endif
+
+static void uncompress_gray(Encoder *encoder, uint8_t *buf, int stride)
+{
+    unsigned int row;
+    uint8_t *prev;
+
+    encoder->channels[0].correlate_row[-1] = 0;
+    quic_one_uncompress_row0(encoder, &encoder->channels[0], (one_byte_t *)buf, encoder->width);
+    encoder->rows_completed++;
+    for (row = 1; row < encoder->height; row++) {
+        prev = buf;
+        buf += stride;
+        encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];
+        quic_one_uncompress_row(encoder, &encoder->channels[0], (one_byte_t *)prev,
+                                (one_byte_t *)buf, encoder->width);
+        encoder->rows_completed++;
+    }
+}
+
+#define QUIC_UNCOMPRESS_RGB(prefix, type)                                                       \
+        encoder->channels[0].correlate_row[-1] = 0;                                             \
+        encoder->channels[1].correlate_row[-1] = 0;                                             \
+        encoder->channels[2].correlate_row[-1] = 0;                                             \
+        quic_rgb##prefix##_uncompress_row0(encoder, (type *)buf, encoder->width);  \
+        encoder->rows_completed++;                                                              \
+        for (row = 1; row < encoder->height; row++) {                                           \
+            prev = buf;                                                                         \
+            buf += stride;                                                                      \
+            encoder->channels[0].correlate_row[-1] = encoder->channels[0].correlate_row[0];     \
+            encoder->channels[1].correlate_row[-1] = encoder->channels[1].correlate_row[0];     \
+            encoder->channels[2].correlate_row[-1] = encoder->channels[2].correlate_row[0];     \
+            quic_rgb##prefix##_uncompress_row(encoder, (type *)prev, (type *)buf,               \
+                                              encoder->width);                                  \
+            encoder->rows_completed++;                                                          \
+        }
+        
+int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride)
+{
+    Encoder *encoder = (Encoder *)quic;
+    unsigned int row;
+    uint8_t *prev;
+#ifndef QUIC_RGB
+    int i;
+#endif
+
+    ASSERT(encoder->usr, buf);
+
+    switch (encoder->type) {
+#ifdef QUIC_RGB
+    case QUIC_IMAGE_TYPE_RGB32:
+    case QUIC_IMAGE_TYPE_RGB24:
+        if (type == QUIC_IMAGE_TYPE_RGB32) {
+            ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+            QUIC_UNCOMPRESS_RGB(32, rgb32_pixel_t);
+            break;
+        } else if (type == QUIC_IMAGE_TYPE_RGB24) {
+            ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 3);
+            QUIC_UNCOMPRESS_RGB(24, rgb24_pixel_t);
+            break;
+        }
+        encoder->usr->warn(encoder->usr, "unsupported output format\n");
+        return QUIC_ERROR;
+    case QUIC_IMAGE_TYPE_RGB16:
+        if (type == QUIC_IMAGE_TYPE_RGB16) {
+            ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 2);
+            QUIC_UNCOMPRESS_RGB(16, rgb16_pixel_t);
+        } else if (type == QUIC_IMAGE_TYPE_RGB32) {
+            ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+            QUIC_UNCOMPRESS_RGB(16_to_32, rgb32_pixel_t);
+        } else {
+            encoder->usr->warn(encoder->usr, "unsupported output format\n");
+            return QUIC_ERROR;
+        }
+
+        break;
+    case QUIC_IMAGE_TYPE_RGBA:
+
+        if (type != QUIC_IMAGE_TYPE_RGBA) {
+            encoder->usr->warn(encoder->usr, "unsupported output format\n");
+            return QUIC_ERROR;
+        }
+        ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+        uncompress_rgba(encoder, buf, stride);
+        break;
+#else
+    case QUIC_IMAGE_TYPE_RGB24:
+        ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 3);
+        for (i = 0; i < 3; i++) {
+            encoder->channels[i].correlate_row[-1] = 0;
+            quic_three_uncompress_row0(encoder, &encoder->channels[i], (three_bytes_t *)(buf + i),
+                                       encoder->width);
+        }
+        encoder->rows_completed++;
+        for (row = 1; row < encoder->height; row++) {
+            prev = buf;
+            buf += stride;
+            for (i = 0; i < 3; i++) {
+                encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
+                quic_three_uncompress_row(encoder, &encoder->channels[i],
+                                          (three_bytes_t *)(prev + i),
+                                          (three_bytes_t *)(buf + i),
+                                          encoder->width);
+            }
+            encoder->rows_completed++;
+        }
+        break;
+    case QUIC_IMAGE_TYPE_RGB32:
+        ASSERT(encoder->usr, ABS(stride) >= encoder->width * 4);
+        for (i = 0; i < 3; i++) {
+            encoder->channels[i].correlate_row[-1] = 0;
+            quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
+                                      encoder->width);
+        }
+        clear_row((four_bytes_t *)(buf + 3), encoder->width);
+        encoder->rows_completed++;
+        for (row = 1; row < encoder->height; row++) {
+            prev = buf;
+            buf += stride;
+            for (i = 0; i < 3; i++) {
+                encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
+                quic_four_uncompress_row(encoder, &encoder->channels[i],
+                                         (four_bytes_t *)(prev + i),
+                                         (four_bytes_t *)(buf + i),
+                                         encoder->width);
+            }
+            clear_row((four_bytes_t *)(buf + 3), encoder->width);
+            encoder->rows_completed++;
+        }
+        break;
+    case QUIC_IMAGE_TYPE_RGBA:
+        ASSERT(encoder->usr, ABS(stride) >= encoder->width * 4);
+        for (i = 0; i < 4; i++) {
+            encoder->channels[i].correlate_row[-1] = 0;
+            quic_four_uncompress_row0(encoder, &encoder->channels[i], (four_bytes_t *)(buf + i),
+                                      encoder->width);
+        }
+        encoder->rows_completed++;
+        for (row = 1; row < encoder->height; row++) {
+            prev = buf;
+            buf += stride;
+            for (i = 0; i < 4; i++) {
+                encoder->channels[i].correlate_row[-1] = encoder->channels[i].correlate_row[0];
+                quic_four_uncompress_row(encoder, &encoder->channels[i],
+                                         (four_bytes_t *)(prev + i),
+                                         (four_bytes_t *)(buf + i),
+                                         encoder->width);
+            }
+            encoder->rows_completed++;
+        }
+        break;
+#endif
+    case QUIC_IMAGE_TYPE_GRAY:
+
+        if (type != QUIC_IMAGE_TYPE_GRAY) {
+            encoder->usr->warn(encoder->usr, "unsupported output format\n");
+            return QUIC_ERROR;
+        }
+        ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width);
+        uncompress_gray(encoder, buf, stride);
+        break;
+    case QUIC_IMAGE_TYPE_INVALID:
+    default:
+        encoder->usr->error(encoder->usr, "bad image type\n");
+    }
+    return QUIC_OK;
+}
+
+static int need_init = TRUE;
+
+QuicContext *quic_create(QuicUsrContext *usr)
+{
+    Encoder *encoder;
+
+    if (!usr || need_init || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
+        !usr->free || !usr->more_space || !usr->more_lines) {
+        return NULL;
+    }
+
+    if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
+        return NULL;
+    }
+
+    if (!init_encoder(encoder, usr)) {
+        usr->free(usr, encoder);
+        return NULL;
+    }
+    return (QuicContext *)encoder;
+}
+
+void quic_destroy(QuicContext *quic)
+{
+    Encoder *encoder = (Encoder *)quic;
+    int i;
+
+    if (!quic) {
+        return;
+    }
+
+    for (i = 0; i < MAX_CHANNELS; i++) {
+        destroy_channel(&encoder->channels[i]);
+    }
+    encoder->usr->free(encoder->usr, encoder);
+}
+
+void quic_init()
+{
+    if (!need_init) {
+        return;
+    }
+    need_init = FALSE;
+
+    family_init(&family_8bpc, 8, DEFmaxclen);
+    family_init(&family_5bpc, 5, DEFmaxclen);
+#if defined(RLE) && defined(RLE_STAT)
+    init_zeroLUT();
+#endif
+}
+
diff --git a/common/quic.h b/common/quic.h
new file mode 100644
index 00000000..8824db7d
--- /dev/null
+++ b/common/quic.h
@@ -0,0 +1,64 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __QUIC_H
+#define __QUIC_H
+
+#include "quic_config.h"
+
+typedef enum {
+    QUIC_IMAGE_TYPE_INVALID,
+    QUIC_IMAGE_TYPE_GRAY,
+    QUIC_IMAGE_TYPE_RGB16,
+    QUIC_IMAGE_TYPE_RGB24,
+    QUIC_IMAGE_TYPE_RGB32,
+    QUIC_IMAGE_TYPE_RGBA
+} QuicImageType;
+
+#define QUIC_ERROR -1
+#define QUIC_OK 0
+
+typedef void *QuicContext;
+
+typedef struct QuicUsrContext QuicUsrContext;
+struct QuicUsrContext {
+    void (*error)(QuicUsrContext *usr, const char *fmt, ...);
+    void (*warn)(QuicUsrContext *usr, const char *fmt, ...);
+    void (*info)(QuicUsrContext *usr, const char *fmt, ...);
+    void *(*malloc)(QuicUsrContext *usr, int size);
+    void (*free)(QuicUsrContext *usr, void *ptr);
+    int (*more_space)(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed);
+    int (*more_lines)(QuicUsrContext *usr, uint8_t **lines); // on return the last line of previous
+                                                             // lines bunch must stil be valid
+};
+
+int quic_encode(QuicContext *quic, QuicImageType type, int width, int height,
+                uint8_t *lines, unsigned int num_lines, int stride,
+                uint32_t *io_ptr, unsigned int num_io_words);
+
+int quic_decode_begin(QuicContext *quic, uint32_t *io_ptr, unsigned int num_io_words,
+                      QuicImageType *type, int *width, int *height);
+int quic_decode(QuicContext *quic, QuicImageType type, uint8_t *buf, int stride);
+
+
+QuicContext *quic_create(QuicUsrContext *usr);
+void quic_destroy(QuicContext *quic);
+
+void quic_init();
+
+#endif
+
diff --git a/common/quic_config.h b/common/quic_config.h
new file mode 100644
index 00000000..ab418b13
--- /dev/null
+++ b/common/quic_config.h
@@ -0,0 +1,53 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __QUIC_CONFIG_H
+#define __QUIC_CONFIG_H
+
+#ifdef __GNUC__
+
+#include <stdint.h>
+#include <string.h>
+
+#define INLINE inline
+
+#define MEMCLEAR(ptr, size) memset(ptr, 0, size)
+
+#else
+
+#ifdef QXLDD
+#include <windef.h>
+#include "os_dep.h"
+#define INLINE _inline
+#define MEMCLEAR(ptr, size) RtlZeroMemory(ptr, size)
+#else
+#include <stddef.h>
+#include <basetsd.h>
+#include <string.h>
+
+#define INLINE inline
+#define MEMCLEAR(ptr, size) memset(ptr, 0, size)
+#endif
+
+typedef UINT32 uint32_t;
+typedef UINT16 uint16_t;
+typedef UINT8 uint8_t;
+
+#endif
+
+#endif
+
diff --git a/common/quic_family_tmpl.c b/common/quic_family_tmpl.c
new file mode 100644
index 00000000..58ae6935
--- /dev/null
+++ b/common/quic_family_tmpl.c
@@ -0,0 +1,114 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef QUIC_FAMILY_8BPC
+#undef QUIC_FAMILY_8BPC
+#define FNAME(name) name##_8bpc
+#define VNAME(name) name##_8bpc
+#define BPC 8
+#endif
+
+
+#ifdef QUIC_FAMILY_5BPC
+#undef QUIC_FAMILY_5BPC
+#define FNAME(name) name##_5bpc
+#define VNAME(name) name##_5bpc
+#define BPC 5
+#endif
+
+
+static unsigned int FNAME(golomb_code_len)(const BYTE n, const unsigned int l)
+{
+    if (n < VNAME(family).nGRcodewords[l]) {
+        return (n >> l) + 1 + l;
+    } else {
+        return VNAME(family).notGRcwlen[l];
+    }
+}
+
+static void FNAME(golomb_coding)(const BYTE n, const unsigned int l, unsigned int * const codeword,
+                                 unsigned int * const codewordlen)
+{
+    if (n < VNAME(family).nGRcodewords[l]) {
+        (*codeword) = bitat[l] | (n & bppmask[l]);
+        (*codewordlen) = (n >> l) + l + 1;
+    } else {
+        (*codeword) = n - VNAME(family).nGRcodewords[l];
+        (*codewordlen) = VNAME(family).notGRcwlen[l];
+    }
+}
+
+unsigned int FNAME(golomb_decoding)(const unsigned int l, const unsigned int bits,
+                                    unsigned int * const codewordlen)
+{
+    if (bits > VNAME(family).notGRprefixmask[l]) { /*GR*/
+        const unsigned int zeroprefix = cnt_l_zeroes(bits);       /* leading zeroes in codeword */
+        const unsigned int cwlen = zeroprefix + 1 + l;            /* codeword length */
+        (*codewordlen) = cwlen;
+        return (zeroprefix << l) | ((bits >> (32 - cwlen)) & bppmask[l]);
+    } else { /* not-GR */
+        const unsigned int cwlen = VNAME(family).notGRcwlen[l];
+        (*codewordlen) = cwlen;
+        return VNAME(family).nGRcodewords[l] + ((bits) >> (32 - cwlen) &
+                                                bppmask[VNAME(family).notGRsuffixlen[l]]);
+    }
+}
+
+/* update the bucket using just encoded curval */
+static void FNAME(update_model)(CommonState *state, s_bucket * const bucket,
+                                const BYTE curval, unsigned int bpp)
+{
+    COUNTER * const pcounters = bucket->pcounters;
+    unsigned int i;
+    unsigned int bestcode;
+    unsigned int bestcodelen;
+    //unsigned int bpp = encoder->bpp;
+
+    /* update counters, find minimum */
+
+    bestcode = bpp - 1;
+    bestcodelen = (pcounters[bestcode] += FNAME(golomb_code_len)(curval, bestcode));
+
+    for (i = bpp - 2; i < bpp; i--) { /* NOTE: expression i<bpp for signed int i would be: i>=0 */
+        const unsigned int ithcodelen = (pcounters[i] += FNAME(golomb_code_len)(curval, i));
+
+        if (ithcodelen < bestcodelen) {
+            bestcode = i;
+            bestcodelen = ithcodelen;
+        }
+    }
+
+    bucket->bestcode = bestcode; /* store the found minimum */
+
+    if (bestcodelen > state->wm_trigger) { /* halving counters? */
+        for (i = 0; i < bpp; i++) {
+            pcounters[i] >>= 1;
+        }
+    }
+}
+
+static s_bucket *FNAME(find_bucket)(Channel *channel, const unsigned int val)
+{
+    ASSERT(channel->encoder->usr, val < (0x1U << BPC));
+
+    return channel->_buckets_ptrs[val];
+}
+
+#undef FNAME
+#undef VNAME
+#undef BPC
+
diff --git a/common/quic_rgb_tmpl.c b/common/quic_rgb_tmpl.c
new file mode 100644
index 00000000..2007df68
--- /dev/null
+++ b/common/quic_rgb_tmpl.c
@@ -0,0 +1,762 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef QUIC_RGB32
+#undef QUIC_RGB32
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) quic_rgb32_##name
+#define golomb_coding golomb_coding_8bpc
+#define golomb_decoding golomb_decoding_8bpc
+#define update_model update_model_8bpc
+#define find_bucket find_bucket_8bpc
+#define family family_8bpc
+#define BPC 8
+#define BPC_MASK 0xffU
+#define COMPRESS_IMP
+#define SET_r(pix, val) ((pix)->r = val)
+#define GET_r(pix) ((pix)->r)
+#define SET_g(pix, val) ((pix)->g = val)
+#define GET_g(pix) ((pix)->g)
+#define SET_b(pix, val) ((pix)->b = val)
+#define GET_b(pix) ((pix)->b)
+#define UNCOMPRESS_PIX_START(pix) ((pix)->pad = 0)
+#endif
+
+#ifdef QUIC_RGB24
+#undef QUIC_RGB24
+#define PIXEL rgb24_pixel_t
+#define FNAME(name) quic_rgb24_##name
+#define golomb_coding golomb_coding_8bpc
+#define golomb_decoding golomb_decoding_8bpc
+#define update_model update_model_8bpc
+#define find_bucket find_bucket_8bpc
+#define family family_8bpc
+#define BPC 8
+#define BPC_MASK 0xffU
+#define COMPRESS_IMP
+#define SET_r(pix, val) ((pix)->r = val)
+#define GET_r(pix) ((pix)->r)
+#define SET_g(pix, val) ((pix)->g = val)
+#define GET_g(pix) ((pix)->g)
+#define SET_b(pix, val) ((pix)->b = val)
+#define GET_b(pix) ((pix)->b)
+#define UNCOMPRESS_PIX_START(pix)
+#endif
+
+#ifdef QUIC_RGB16
+#undef QUIC_RGB16
+#define PIXEL rgb16_pixel_t
+#define FNAME(name) quic_rgb16_##name
+#define golomb_coding golomb_coding_5bpc
+#define golomb_decoding golomb_decoding_5bpc
+#define update_model update_model_5bpc
+#define find_bucket find_bucket_5bpc
+#define family family_5bpc
+#define BPC 5
+#define BPC_MASK 0x1fU
+#define COMPRESS_IMP
+#define SET_r(pix, val) (*(pix) = (*(pix) & ~(0x1f << 10)) | ((val) << 10))
+#define GET_r(pix) ((*(pix) >> 10) & 0x1f)
+#define SET_g(pix, val) (*(pix) = (*(pix) & ~(0x1f << 5)) | ((val) << 5))
+#define GET_g(pix) ((*(pix) >> 5) & 0x1f)
+#define SET_b(pix, val) (*(pix) = (*(pix) & ~0x1f) | (val))
+#define GET_b(pix) (*(pix) & 0x1f)
+#define UNCOMPRESS_PIX_START(pix) (*(pix) = 0)
+#endif
+
+#ifdef QUIC_RGB16_TO_32
+#undef QUIC_RGB16_TO_32
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) quic_rgb16_to_32_##name
+#define golomb_coding golomb_coding_5bpc
+#define golomb_decoding golomb_decoding_5bpc
+#define update_model update_model_5bpc
+#define find_bucket find_bucket_5bpc
+#define family family_5bpc
+#define BPC 5
+#define BPC_MASK 0x1fU
+
+#define SET_r(pix, val) ((pix)->r = ((val) << 3) | (((val) & 0x1f) >> 2))
+#define GET_r(pix) ((pix)->r >> 3)
+#define SET_g(pix, val) ((pix)->g = ((val) << 3) | (((val) & 0x1f) >> 2))
+#define GET_g(pix) ((pix)->g >> 3)
+#define SET_b(pix, val) ((pix)->b = ((val) << 3) | (((val) & 0x1f) >> 2))
+#define GET_b(pix) ((pix)->b >> 3)
+#define UNCOMPRESS_PIX_START(pix) ((pix)->pad = 0)
+#endif
+
+#define SAME_PIXEL(p1, p2)                                 \
+    (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) &&   \
+     GET_b(p1) == GET_b(p2))
+
+
+#define _PIXEL_A(channel, curr) ((unsigned int)GET_##channel((curr) - 1))
+#define _PIXEL_B(channel, prev) ((unsigned int)GET_##channel(prev))
+#define _PIXEL_C(channel, prev) ((unsigned int)GET_##channel((prev) - 1))
+
+/*  a  */
+
+#define DECORELATE_0(channel, curr, bpc_mask)\
+    family.xlatU2L[(unsigned)((int)GET_##channel(curr) - (int)_PIXEL_A(channel, curr)) & bpc_mask]
+
+#define CORELATE_0(channel, curr, correlate, bpc_mask)\
+    ((family.xlatL2U[correlate] + _PIXEL_A(channel, curr)) & bpc_mask)
+
+#ifdef PRED_1
+
+/*  (a+b)/2  */
+#define DECORELATE(channel, prev, curr, bpc_mask, r)                                            \
+    r = family.xlatU2L[(unsigned)((int)GET_##channel(curr) - (int)((_PIXEL_A(channel, curr) +   \
+                        _PIXEL_B(channel, prev)) >> 1)) & bpc_mask]
+
+#define CORELATE(channel, prev, curr, correlate, bpc_mask, r)                                   \
+    SET_##channel(r, ((family.xlatL2U[correlate] +                                              \
+          (int)((_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev)) >> 1)) & bpc_mask))
+#endif
+
+#ifdef PRED_2
+
+/*  .75a+.75b-.5c  */
+#define DECORELATE(channel, prev, curr, bpc_mask, r) {                          \
+    int p = ((int)(3 * (_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev))) -   \
+                        (int)(_PIXEL_C(channel, prev) << 1)) >> 2;              \
+    if (p < 0) {                                                                \
+        p = 0;                                                                  \
+    } else if ((unsigned)p > bpc_mask) {                                        \
+        p = bpc_mask;                                                           \
+    }                                                                           \
+    r = family.xlatU2L[(unsigned)((int)GET_##channel(curr) - p) & bpc_mask];    \
+}
+
+#define CORELATE(channel, prev, curr, correlate, bpc_mask, r) {                         \
+    const int p = ((int)(3 * (_PIXEL_A(channel, curr) + _PIXEL_B(channel, prev))) -     \
+                        (int)(_PIXEL_C(channel, prev) << 1) ) >> 2;                     \
+    const unsigned int s = family.xlatL2U[correlate];                                   \
+    if (!(p & ~bpc_mask)) {                                                             \
+        SET_##channel(r, (s + (unsigned)p) & bpc_mask);                                 \
+    } else if (p < 0) {                                                                 \
+        SET_##channel(r, s);                                                            \
+    } else {                                                                            \
+        SET_##channel(r, (s + bpc_mask) & bpc_mask);                                    \
+    }                                                                                   \
+}
+
+#endif
+
+
+#define COMPRESS_ONE_ROW0_0(channel)                                                \
+    correlate_row_##channel[0] = family.xlatU2L[GET_##channel(cur_row)];            \
+    golomb_coding(correlate_row_##channel[0], find_bucket(channel_##channel,        \
+                  correlate_row_##channel[-1])->bestcode,                           \
+                  &codeword, &codewordlen);                                         \
+    encode(encoder, codeword, codewordlen);
+
+#define COMPRESS_ONE_ROW0(channel, index)                                               \
+    correlate_row_##channel[index] = DECORELATE_0(channel, &cur_row[index], bpc_mask);  \
+    golomb_coding(correlate_row_##channel[index], find_bucket(channel_##channel,        \
+                  correlate_row_##channel[index -1])->bestcode,                         \
+                  &codeword, &codewordlen);                                             \
+    encode(encoder, codeword, codewordlen);
+
+#define UPDATE_MODEL(index)                                                                 \
+    update_model(&encoder->rgb_state, find_bucket(channel_r, correlate_row_r[index - 1]),   \
+                correlate_row_r[index], bpc);                                               \
+    update_model(&encoder->rgb_state, find_bucket(channel_g, correlate_row_g[index - 1]),   \
+                correlate_row_g[index], bpc);                                               \
+    update_model(&encoder->rgb_state, find_bucket(channel_b, correlate_row_b[index - 1]),   \
+                correlate_row_b[index], bpc);
+
+
+#ifdef RLE_PRED_1
+#define RLE_PRED_1_IMP                                                                          \
+if (SAME_PIXEL(&cur_row[i - 1], &prev_row[i])) {                                                \
+    if (run_index != i && SAME_PIXEL(&prev_row[i - 1], &prev_row[i]) &&                         \
+                                i + 1 < end && SAME_PIXEL(&prev_row[i], &prev_row[i + 1])) {    \
+        goto do_run;                                                                            \
+    }                                                                                           \
+}
+#else
+#define RLE_PRED_1_IMP
+#endif
+
+#ifdef RLE_PRED_2
+#define RLE_PRED_2_IMP                                                              \
+if (SAME_PIXEL(&prev_row[i - 1], &prev_row[i])) {                                   \
+    if (run_index != i && i > 2 && SAME_PIXEL(&cur_row[i - 1], &cur_row[i - 2])) {  \
+        goto do_run;                                                                \
+    }                                                                               \
+}
+#else
+#define RLE_PRED_2_IMP
+#endif
+
+#ifdef RLE_PRED_3
+#define RLE_PRED_3_IMP                                                              \
+if (i > 1 &&  SAME_PIXEL(&cur_row[i - 1], &cur_row[i - 2]) && i != run_index) {     \
+    goto do_run;                                                                    \
+}
+#else
+#define RLE_PRED_3_IMP
+#endif
+
+#ifdef COMPRESS_IMP
+
+static void FNAME(compress_row0_seg)(Encoder *encoder, int i,
+                                     const PIXEL * const cur_row,
+                                     const int end,
+                                     const unsigned int waitmask,
+                                     const unsigned int bpc,
+                                     const unsigned int bpc_mask)
+{
+    Channel * const channel_r = encoder->channels;
+    Channel * const channel_g = channel_r + 1;
+    Channel * const channel_b = channel_g + 1;
+
+    BYTE * const correlate_row_r = channel_r->correlate_row;
+    BYTE * const correlate_row_g = channel_g->correlate_row;
+    BYTE * const correlate_row_b = channel_b->correlate_row;
+    int stopidx;
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (!i) {
+        unsigned int codeword, codewordlen;
+
+        COMPRESS_ONE_ROW0_0(r);
+        COMPRESS_ONE_ROW0_0(g);
+        COMPRESS_ONE_ROW0_0(b);
+
+        if (encoder->rgb_state.waitcnt) {
+            encoder->rgb_state.waitcnt--;
+        } else {
+            encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+            UPDATE_MODEL(0);
+        }
+        stopidx = ++i + encoder->rgb_state.waitcnt;
+    } else {
+        stopidx = i + encoder->rgb_state.waitcnt;
+    }
+
+    while (stopidx < end) {
+        for (; i <= stopidx; i++) {
+            unsigned int codeword, codewordlen;
+            COMPRESS_ONE_ROW0(r, i);
+            COMPRESS_ONE_ROW0(g, i);
+            COMPRESS_ONE_ROW0(b, i);
+        }
+
+        UPDATE_MODEL(stopidx);
+        stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+    }
+
+    for (; i < end; i++) {
+        unsigned int codeword, codewordlen;
+
+        COMPRESS_ONE_ROW0(r, i);
+        COMPRESS_ONE_ROW0(g, i);
+        COMPRESS_ONE_ROW0(b, i);
+    }
+    encoder->rgb_state.waitcnt = stopidx - end;
+}
+
+static void FNAME(compress_row0)(Encoder *encoder, const PIXEL *cur_row,
+                                 unsigned int width)
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    int pos = 0;
+
+    while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
+        if (encoder->rgb_state.wmileft) {
+            FNAME(compress_row0_seg)(encoder, pos, cur_row, pos + encoder->rgb_state.wmileft,
+                                     bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
+            width -= encoder->rgb_state.wmileft;
+            pos += encoder->rgb_state.wmileft;
+        }
+
+        encoder->rgb_state.wmidx++;
+        set_wm_trigger(&encoder->rgb_state);
+        encoder->rgb_state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(compress_row0_seg)(encoder, pos, cur_row, pos + width,
+                                 bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)encoder->rgb_state.wmidx) {
+            encoder->rgb_state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
+    ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+#define COMPRESS_ONE_0(channel) \
+    correlate_row_##channel[0] = family.xlatU2L[(unsigned)((int)GET_##channel(cur_row) -    \
+                                                (int)GET_##channel(prev_row) ) & bpc_mask]; \
+    golomb_coding(correlate_row_##channel[0],                                               \
+                  find_bucket(channel_##channel, correlate_row_##channel[-1])->bestcode,    \
+                  &codeword, &codewordlen);                                                 \
+    encode(encoder, codeword, codewordlen);
+
+#define COMPRESS_ONE(channel, index)                                                            \
+    DECORELATE(channel, &prev_row[index], &cur_row[index],bpc_mask,                             \
+               correlate_row_##channel[index]);                                                 \
+    golomb_coding(correlate_row_##channel[index],                                               \
+                 find_bucket(channel_##channel, correlate_row_##channel[index - 1])->bestcode,  \
+                 &codeword, &codewordlen);                                                      \
+    encode(encoder, codeword, codewordlen);
+
+static void FNAME(compress_row_seg)(Encoder *encoder, int i,
+                                    const PIXEL * const prev_row,
+                                    const PIXEL * const cur_row,
+                                    const int end,
+                                    const unsigned int waitmask,
+                                    const unsigned int bpc,
+                                    const unsigned int bpc_mask)
+{
+    Channel * const channel_r = encoder->channels;
+    Channel * const channel_g = channel_r + 1;
+    Channel * const channel_b = channel_g + 1;
+
+    BYTE * const correlate_row_r = channel_r->correlate_row;
+    BYTE * const correlate_row_g = channel_g->correlate_row;
+    BYTE * const correlate_row_b = channel_b->correlate_row;
+    int stopidx;
+#ifdef RLE
+    int run_index = 0;
+    int run_size;
+#endif
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (!i) {
+        unsigned int codeword, codewordlen;
+
+        COMPRESS_ONE_0(r);
+        COMPRESS_ONE_0(g);
+        COMPRESS_ONE_0(b);
+
+        if (encoder->rgb_state.waitcnt) {
+            encoder->rgb_state.waitcnt--;
+        } else {
+            encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+            UPDATE_MODEL(0);
+        }
+        stopidx = ++i + encoder->rgb_state.waitcnt;
+    } else {
+        stopidx = i + encoder->rgb_state.waitcnt;
+    }
+    for (;;) {
+        while (stopidx < end) {
+            for (; i <= stopidx; i++) {
+                unsigned int codeword, codewordlen;
+#ifdef RLE
+                RLE_PRED_1_IMP;
+                RLE_PRED_2_IMP;
+                RLE_PRED_3_IMP;
+#endif
+                COMPRESS_ONE(r, i);
+                COMPRESS_ONE(g, i);
+                COMPRESS_ONE(b, i);
+            }
+
+            UPDATE_MODEL(stopidx);
+            stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+        }
+
+        for (; i < end; i++) {
+            unsigned int codeword, codewordlen;
+#ifdef RLE
+            RLE_PRED_1_IMP;
+            RLE_PRED_2_IMP;
+            RLE_PRED_3_IMP;
+#endif
+            COMPRESS_ONE(r, i);
+            COMPRESS_ONE(g, i);
+            COMPRESS_ONE(b, i);
+        }
+        encoder->rgb_state.waitcnt = stopidx - end;
+
+        return;
+
+#ifdef RLE
+do_run:
+        run_index = i;
+        encoder->rgb_state.waitcnt = stopidx - i;
+        run_size = 0;
+
+        while (SAME_PIXEL(&cur_row[i], &cur_row[i - 1])) {
+            run_size++;
+            if (++i == end) {
+                encode_run(encoder, run_size);
+                return;
+            }
+        }
+        encode_run(encoder, run_size);
+        stopidx = i + encoder->rgb_state.waitcnt;
+#endif
+    }
+}
+
+static void FNAME(compress_row)(Encoder *encoder,
+                                const PIXEL * const prev_row,
+                                const PIXEL * const cur_row,
+                                unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
+        if (encoder->rgb_state.wmileft) {
+            FNAME(compress_row_seg)(encoder, pos, prev_row, cur_row,
+                                    pos + encoder->rgb_state.wmileft,
+                                    bppmask[encoder->rgb_state.wmidx],
+                                    bpc, bpc_mask);
+            width -= encoder->rgb_state.wmileft;
+            pos += encoder->rgb_state.wmileft;
+        }
+
+        encoder->rgb_state.wmidx++;
+        set_wm_trigger(&encoder->rgb_state);
+        encoder->rgb_state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(compress_row_seg)(encoder, pos, prev_row, cur_row, pos + width,
+                                bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)encoder->rgb_state.wmidx) {
+            encoder->rgb_state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
+    ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+#endif
+
+#define UNCOMPRESS_ONE_ROW0_0(channel)                                                          \
+    correlate_row_##channel[0] = (BYTE)golomb_decoding(find_bucket(channel_##channel,           \
+                                                       correlate_row_##channel[-1])->bestcode,  \
+                                                       encoder->io_word, &codewordlen);         \
+    SET_##channel(&cur_row[0], (BYTE)family.xlatL2U[correlate_row_##channel[0]]);               \
+    decode_eatbits(encoder, codewordlen);
+
+#define UNCOMPRESS_ONE_ROW0(channel)                                                              \
+    correlate_row_##channel[i] = (BYTE)golomb_decoding(find_bucket(channel_##channel,             \
+                                                       correlate_row_##channel[i - 1])->bestcode, \
+                                                       encoder->io_word,                          \
+                                                       &codewordlen);                             \
+    SET_##channel(&cur_row[i], CORELATE_0(channel, &cur_row[i], correlate_row_##channel[i],       \
+                  bpc_mask));                                                                     \
+    decode_eatbits(encoder, codewordlen);
+
+static void FNAME(uncompress_row0_seg)(Encoder *encoder, int i,
+                                       PIXEL * const cur_row,
+                                       const int end,
+                                       const unsigned int waitmask,
+                                       const unsigned int bpc,
+                                       const unsigned int bpc_mask)
+{
+    Channel * const channel_r = encoder->channels;
+    Channel * const channel_g = channel_r + 1;
+    Channel * const channel_b = channel_g + 1;
+
+    BYTE * const correlate_row_r = channel_r->correlate_row;
+    BYTE * const correlate_row_g = channel_g->correlate_row;
+    BYTE * const correlate_row_b = channel_b->correlate_row;
+    int stopidx;
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (!i) {
+        unsigned int codewordlen;
+
+        UNCOMPRESS_PIX_START(&cur_row[i]);
+        UNCOMPRESS_ONE_ROW0_0(r);
+        UNCOMPRESS_ONE_ROW0_0(g);
+        UNCOMPRESS_ONE_ROW0_0(b);
+
+        if (encoder->rgb_state.waitcnt) {
+            --encoder->rgb_state.waitcnt;
+        } else {
+            encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+            UPDATE_MODEL(0);
+        }
+        stopidx = ++i + encoder->rgb_state.waitcnt;
+    } else {
+        stopidx = i + encoder->rgb_state.waitcnt;
+    }
+
+    while (stopidx < end) {
+        for (; i <= stopidx; i++) {
+            unsigned int codewordlen;
+
+            UNCOMPRESS_PIX_START(&cur_row[i]);
+            UNCOMPRESS_ONE_ROW0(r);
+            UNCOMPRESS_ONE_ROW0(g);
+            UNCOMPRESS_ONE_ROW0(b);
+        }
+        UPDATE_MODEL(stopidx);
+        stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+    }
+
+    for (; i < end; i++) {
+        unsigned int codewordlen;
+
+        UNCOMPRESS_PIX_START(&cur_row[i]);
+        UNCOMPRESS_ONE_ROW0(r);
+        UNCOMPRESS_ONE_ROW0(g);
+        UNCOMPRESS_ONE_ROW0(b);
+    }
+    encoder->rgb_state.waitcnt = stopidx - end;
+}
+
+static void FNAME(uncompress_row0)(Encoder *encoder,
+                                   PIXEL * const cur_row,
+                                   unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
+        if (encoder->rgb_state.wmileft) {
+            FNAME(uncompress_row0_seg)(encoder, pos, cur_row,
+                                       pos + encoder->rgb_state.wmileft,
+                                       bppmask[encoder->rgb_state.wmidx],
+                                       bpc, bpc_mask);
+            pos += encoder->rgb_state.wmileft;
+            width -= encoder->rgb_state.wmileft;
+        }
+
+        encoder->rgb_state.wmidx++;
+        set_wm_trigger(&encoder->rgb_state);
+        encoder->rgb_state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(uncompress_row0_seg)(encoder, pos, cur_row, pos + width,
+                                   bppmask[encoder->rgb_state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)encoder->rgb_state.wmidx) {
+            encoder->rgb_state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
+    ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+#define UNCOMPRESS_ONE_0(channel) \
+    correlate_row_##channel[0] = (BYTE)golomb_decoding(find_bucket(channel_##channel,           \
+                                                       correlate_row_##channel[-1])->bestcode,  \
+                                                       encoder->io_word, &codewordlen);         \
+    SET_##channel(&cur_row[0], (family.xlatL2U[correlate_row_##channel[0]] +                    \
+                          GET_##channel(prev_row)) & bpc_mask);                                 \
+    decode_eatbits(encoder, codewordlen);
+
+#define UNCOMPRESS_ONE(channel)                                                                   \
+    correlate_row_##channel[i] = (BYTE)golomb_decoding(find_bucket(channel_##channel,             \
+                                                       correlate_row_##channel[i - 1])->bestcode, \
+                                                       encoder->io_word,                          \
+                                                       &codewordlen);                             \
+    CORELATE(channel, &prev_row[i], &cur_row[i], correlate_row_##channel[i], bpc_mask,            \
+             &cur_row[i]);                                                                        \
+    decode_eatbits(encoder, codewordlen);
+
+static void FNAME(uncompress_row_seg)(Encoder *encoder,
+                                      const PIXEL * const prev_row,
+                                      PIXEL * const cur_row,
+                                      int i,
+                                      const int end,
+                                      const unsigned int bpc,
+                                      const unsigned int bpc_mask)
+{
+    Channel * const channel_r = encoder->channels;
+    Channel * const channel_g = channel_r + 1;
+    Channel * const channel_b = channel_g + 1;
+
+    BYTE * const correlate_row_r = channel_r->correlate_row;
+    BYTE * const correlate_row_g = channel_g->correlate_row;
+    BYTE * const correlate_row_b = channel_b->correlate_row;
+    const unsigned int waitmask = bppmask[encoder->rgb_state.wmidx];
+    int stopidx;
+#ifdef RLE
+    int run_index = 0;
+    int run_end;
+#endif
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (!i) {
+        unsigned int codewordlen;
+
+        UNCOMPRESS_PIX_START(&cur_row[i]);
+        UNCOMPRESS_ONE_0(r);
+        UNCOMPRESS_ONE_0(g);
+        UNCOMPRESS_ONE_0(b);
+
+        if (encoder->rgb_state.waitcnt) {
+            --encoder->rgb_state.waitcnt;
+        } else {
+            encoder->rgb_state.waitcnt = (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+            UPDATE_MODEL(0);
+        }
+        stopidx = ++i + encoder->rgb_state.waitcnt;
+    } else {
+        stopidx = i + encoder->rgb_state.waitcnt;
+    }
+    for (;;) {
+        while (stopidx < end) {
+            for (; i <= stopidx; i++) {
+                unsigned int codewordlen;
+#ifdef RLE
+                RLE_PRED_1_IMP;
+                RLE_PRED_2_IMP;
+                RLE_PRED_3_IMP;
+#endif
+                UNCOMPRESS_PIX_START(&cur_row[i]);
+                UNCOMPRESS_ONE(r);
+                UNCOMPRESS_ONE(g);
+                UNCOMPRESS_ONE(b);
+            }
+
+            UPDATE_MODEL(stopidx);
+
+            stopidx = i + (tabrand(&encoder->rgb_state.tabrand_seed) & waitmask);
+        }
+
+        for (; i < end; i++) {
+            unsigned int codewordlen;
+#ifdef RLE
+            RLE_PRED_1_IMP;
+            RLE_PRED_2_IMP;
+            RLE_PRED_3_IMP;
+#endif
+            UNCOMPRESS_PIX_START(&cur_row[i]);
+            UNCOMPRESS_ONE(r);
+            UNCOMPRESS_ONE(g);
+            UNCOMPRESS_ONE(b);
+        }
+
+        encoder->rgb_state.waitcnt = stopidx - end;
+
+        return;
+
+#ifdef RLE
+do_run:
+        encoder->rgb_state.waitcnt = stopidx - i;
+        run_index = i;
+        run_end = i + decode_run(encoder);
+
+        for (; i < run_end; i++) {
+            UNCOMPRESS_PIX_START(&cur_row[i]);
+            SET_r(&cur_row[i], GET_r(&cur_row[i - 1]));
+            SET_g(&cur_row[i], GET_g(&cur_row[i - 1]));
+            SET_b(&cur_row[i], GET_b(&cur_row[i - 1]));
+        }
+
+        if (i == end) {
+            return;
+        }
+
+        stopidx = i + encoder->rgb_state.waitcnt;
+#endif
+    }
+}
+
+static void FNAME(uncompress_row)(Encoder *encoder,
+                                  const PIXEL * const prev_row,
+                                  PIXEL * const cur_row,
+                                  unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)encoder->rgb_state.wmidx) && (encoder->rgb_state.wmileft <= width)) {
+        if (encoder->rgb_state.wmileft) {
+            FNAME(uncompress_row_seg)(encoder, prev_row, cur_row, pos,
+                                      pos + encoder->rgb_state.wmileft, bpc, bpc_mask);
+            pos += encoder->rgb_state.wmileft;
+            width -= encoder->rgb_state.wmileft;
+        }
+
+        encoder->rgb_state.wmidx++;
+        set_wm_trigger(&encoder->rgb_state);
+        encoder->rgb_state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(uncompress_row_seg)(encoder, prev_row, cur_row, pos,
+                                  pos + width, bpc, bpc_mask);
+        if (wmimax > (int)encoder->rgb_state.wmidx) {
+            encoder->rgb_state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)encoder->rgb_state.wmidx <= wmimax);
+    ASSERT(encoder->usr, encoder->rgb_state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+#undef PIXEL
+#undef FNAME
+#undef _PIXEL_A
+#undef _PIXEL_B
+#undef _PIXEL_C
+#undef SAME_PIXEL
+#undef RLE_PRED_1_IMP
+#undef RLE_PRED_2_IMP
+#undef RLE_PRED_3_IMP
+#undef UPDATE_MODEL
+#undef DECORELATE_0
+#undef DECORELATE
+#undef COMPRESS_ONE_ROW0_0
+#undef COMPRESS_ONE_ROW0
+#undef COMPRESS_ONE_0
+#undef COMPRESS_ONE
+#undef CORELATE_0
+#undef CORELATE
+#undef UNCOMPRESS_ONE_ROW0_0
+#undef UNCOMPRESS_ONE_ROW0
+#undef UNCOMPRESS_ONE_0
+#undef UNCOMPRESS_ONE
+#undef golomb_coding
+#undef golomb_decoding
+#undef update_model
+#undef find_bucket
+#undef family
+#undef BPC
+#undef BPC_MASK
+#undef COMPRESS_IMP
+#undef SET_r
+#undef GET_r
+#undef SET_g
+#undef GET_g
+#undef SET_b
+#undef GET_b
+#undef UNCOMPRESS_PIX_START
+
diff --git a/common/quic_tmpl.c b/common/quic_tmpl.c
new file mode 100644
index 00000000..5a0a8e55
--- /dev/null
+++ b/common/quic_tmpl.c
@@ -0,0 +1,632 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef ONE_BYTE
+#undef ONE_BYTE
+#define FNAME(name) quic_one_##name
+#define PIXEL one_byte_t
+#endif
+
+#ifdef THREE_BYTE
+#undef THREE_BYTE
+#define FNAME(name) quic_three_##name
+#define PIXEL three_bytes_t
+#endif
+
+#ifdef FOUR_BYTE
+#undef FOUR_BYTE
+#define FNAME(name) quic_four_##name
+#define PIXEL four_bytes_t
+#endif
+
+#define golomb_coding golomb_coding_8bpc
+#define golomb_decoding golomb_decoding_8bpc
+#define update_model update_model_8bpc
+#define find_bucket find_bucket_8bpc
+#define family family_8bpc
+
+#define BPC 8
+#define BPC_MASK 0xffU
+
+#define _PIXEL_A ((unsigned int)curr[-1].a)
+#define _PIXEL_B ((unsigned int)prev[0].a)
+#define _PIXEL_C ((unsigned int)prev[-1].a)
+
+#ifdef RLE_PRED_1
+#define RLE_PRED_1_IMP                                                              \
+if (cur_row[i - 1].a == prev_row[i].a) {                                            \
+    if (run_index != i && prev_row[i - 1].a == prev_row[i].a &&                     \
+                        i + 1 < end && prev_row[i].a == prev_row[i + 1].a) {        \
+        goto do_run;                                                                \
+    }                                                                               \
+}
+#else
+#define RLE_PRED_1_IMP
+#endif
+
+#ifdef RLE_PRED_2
+#define RLE_PRED_2_IMP                                                     \
+if (prev_row[i - 1].a == prev_row[i].a) {                                  \
+    if (run_index != i && i > 2 && cur_row[i - 1].a == cur_row[i - 2].a) { \
+        goto do_run;                                                       \
+    }                                                                      \
+}
+#else
+#define RLE_PRED_2_IMP
+#endif
+
+#ifdef RLE_PRED_3
+#define RLE_PRED_3_IMP                                                  \
+if (i > 1 && cur_row[i - 1].a == cur_row[i - 2].a && i != run_index) {  \
+    goto do_run;                                                        \
+}
+#else
+#define RLE_PRED_3_IMP
+#endif
+
+/*  a  */
+static INLINE BYTE FNAME(decorelate_0)(const PIXEL * const curr, const unsigned int bpc_mask)
+{
+    return family.xlatU2L[(unsigned)((int)curr[0].a - (int)_PIXEL_A) & bpc_mask];
+}
+
+static INLINE void FNAME(corelate_0)(PIXEL *curr, const BYTE corelate,
+                                     const unsigned int bpc_mask)
+{
+    curr->a = (family.xlatL2U[corelate] + _PIXEL_A) & bpc_mask;
+}
+
+#ifdef PRED_1
+
+/*  (a+b)/2  */
+static INLINE BYTE FNAME(decorelate)(const PIXEL *const prev, const PIXEL * const curr,
+                                     const unsigned int bpc_mask)
+{
+    return family.xlatU2L[(unsigned)((int)curr->a - (int)((_PIXEL_A + _PIXEL_B) >> 1)) & bpc_mask];
+}
+
+
+static INLINE void FNAME(corelate)(const PIXEL *prev, PIXEL *curr, const BYTE corelate,
+                                   const unsigned int bpc_mask)
+{
+    curr->a = (family.xlatL2U[corelate] + (int)((_PIXEL_A + _PIXEL_B) >> 1)) & bpc_mask;
+}
+
+#endif
+
+#ifdef PRED_2
+
+/*  .75a+.75b-.5c  */
+static INLINE BYTE FNAME(decorelate)(const PIXEL *const prev, const PIXEL * const curr,
+                                     const unsigned int bpc_mask)
+{
+    int p = ((int)(3 * (_PIXEL_A + _PIXEL_B)) - (int)(_PIXEL_C << 1)) >> 2;
+
+    if (p < 0) {
+        p = 0;
+    } else if ((unsigned)p > bpc_mask) {
+        p = bpc_mask;
+    }
+
+    {
+        return family.xlatU2L[(unsigned)((int)curr->a - p) & bpc_mask];
+    }
+}
+
+static INLINE void FNAME(corelate)(const PIXEL *prev, PIXEL *curr, const BYTE corelate,
+                                   const unsigned int bpc_mask)
+{
+    const int p = ((int)(3 * (_PIXEL_A + _PIXEL_B)) - (int)(_PIXEL_C << 1)) >> 2;
+    const unsigned int s = family.xlatL2U[corelate];
+
+    if (!(p & ~bpc_mask)) {
+        curr->a = (s + (unsigned)p) & bpc_mask;
+    } else if (p < 0) {
+        curr->a = s;
+    } else {
+        curr->a = (s + bpc_mask) & bpc_mask;
+    }
+}
+
+#endif
+
+static void FNAME(compress_row0_seg)(Encoder *encoder, Channel *channel, int i,
+                                     const PIXEL * const cur_row,
+                                     const int end,
+                                     const unsigned int waitmask,
+                                     const unsigned int bpc,
+                                     const unsigned int bpc_mask)
+{
+    BYTE * const decorelate_drow = channel->correlate_row;
+    int stopidx;
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (i == 0) {
+        unsigned int codeword, codewordlen;
+
+        decorelate_drow[0] = family.xlatU2L[cur_row->a];
+        golomb_coding(decorelate_drow[0], find_bucket(channel, decorelate_drow[-1])->bestcode,
+                      &codeword, &codewordlen);
+        encode(encoder, codeword, codewordlen);
+
+        if (channel->state.waitcnt) {
+            channel->state.waitcnt--;
+        } else {
+            channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
+            update_model(&channel->state, find_bucket(channel, decorelate_drow[-1]),
+                         decorelate_drow[i], bpc);
+        }
+        stopidx = ++i + channel->state.waitcnt;
+    } else {
+        stopidx = i + channel->state.waitcnt;
+    }
+
+    while (stopidx < end) {
+        for (; i <= stopidx; i++) {
+            unsigned int codeword, codewordlen;
+            decorelate_drow[i] = FNAME(decorelate_0)(&cur_row[i], bpc_mask);
+            golomb_coding(decorelate_drow[i],
+                          find_bucket(channel, decorelate_drow[i - 1])->bestcode, &codeword,
+                          &codewordlen);
+            encode(encoder, codeword, codewordlen);
+        }
+
+        update_model(&channel->state, find_bucket(channel, decorelate_drow[stopidx - 1]),
+                     decorelate_drow[stopidx], bpc);
+        stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
+    }
+
+    for (; i < end; i++) {
+        unsigned int codeword, codewordlen;
+        decorelate_drow[i] = FNAME(decorelate_0)(&cur_row[i], bpc_mask);
+        golomb_coding(decorelate_drow[i], find_bucket(channel, decorelate_drow[i - 1])->bestcode,
+                      &codeword, &codewordlen);
+        encode(encoder, codeword, codewordlen);
+    }
+    channel->state.waitcnt = stopidx - end;
+}
+
+static void FNAME(compress_row0)(Encoder *encoder, Channel *channel, const PIXEL *cur_row,
+                                 unsigned int width)
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    int pos = 0;
+
+    while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
+        if (channel->state.wmileft) {
+            FNAME(compress_row0_seg)(encoder, channel, pos, cur_row, pos + channel->state.wmileft,
+                                     bppmask[channel->state.wmidx], bpc, bpc_mask);
+            width -= channel->state.wmileft;
+            pos += channel->state.wmileft;
+        }
+
+        channel->state.wmidx++;
+        set_wm_trigger(&channel->state);
+        channel->state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(compress_row0_seg)(encoder, channel, pos, cur_row, pos + width,
+                                 bppmask[channel->state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)channel->state.wmidx) {
+            channel->state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
+    ASSERT(encoder->usr, channel->state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+static void FNAME(compress_row_seg)(Encoder *encoder, Channel *channel, int i,
+                                    const PIXEL * const prev_row,
+                                    const PIXEL * const cur_row,
+                                    const int end,
+                                    const unsigned int waitmask,
+                                    const unsigned int bpc,
+                                    const unsigned int bpc_mask)
+{
+    BYTE * const decorelate_drow = channel->correlate_row;
+    int stopidx;
+#ifdef RLE
+    int run_index = 0;
+    int run_size;
+#endif
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (!i) {
+        unsigned int codeword, codewordlen;
+
+        decorelate_drow[0] = family.xlatU2L[(unsigned)((int)cur_row->a -
+                                                       (int)prev_row->a) & bpc_mask];
+
+        golomb_coding(decorelate_drow[0],
+                      find_bucket(channel, decorelate_drow[-1])->bestcode,
+                      &codeword,
+                      &codewordlen);
+        encode(encoder, codeword, codewordlen);
+
+        if (channel->state.waitcnt) {
+            channel->state.waitcnt--;
+        } else {
+            channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
+            update_model(&channel->state, find_bucket(channel, decorelate_drow[-1]),
+                         decorelate_drow[0], bpc);
+        }
+        stopidx = ++i + channel->state.waitcnt;
+    } else {
+        stopidx = i + channel->state.waitcnt;
+    }
+    for (;;) {
+        while (stopidx < end) {
+            for (; i <= stopidx; i++) {
+                unsigned int codeword, codewordlen;
+#ifdef RLE
+                RLE_PRED_1_IMP;
+                RLE_PRED_2_IMP;
+                RLE_PRED_3_IMP;
+#endif
+                decorelate_drow[i] = FNAME(decorelate)(&prev_row[i], &cur_row[i], bpc_mask);
+                golomb_coding(decorelate_drow[i],
+                              find_bucket(channel, decorelate_drow[i - 1])->bestcode, &codeword,
+                              &codewordlen);
+                encode(encoder, codeword, codewordlen);
+            }
+
+            update_model(&channel->state, find_bucket(channel, decorelate_drow[stopidx - 1]),
+                         decorelate_drow[stopidx], bpc);
+            stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
+        }
+
+        for (; i < end; i++) {
+            unsigned int codeword, codewordlen;
+#ifdef RLE
+            RLE_PRED_1_IMP;
+            RLE_PRED_2_IMP;
+            RLE_PRED_3_IMP;
+#endif
+            decorelate_drow[i] = FNAME(decorelate)(&prev_row[i], &cur_row[i], bpc_mask);
+            golomb_coding(decorelate_drow[i], find_bucket(channel,
+                                                          decorelate_drow[i - 1])->bestcode,
+                          &codeword, &codewordlen);
+            encode(encoder, codeword, codewordlen);
+        }
+        channel->state.waitcnt = stopidx - end;
+
+        return;
+
+#ifdef RLE
+do_run:
+        run_index = i;
+        channel->state.waitcnt = stopidx - i;
+        run_size = 0;
+
+        while (cur_row[i].a == cur_row[i - 1].a) {
+            run_size++;
+            if (++i == end) {
+#ifdef RLE_STAT
+                encode_channel_run(encoder, channel, run_size);
+#else
+                encode_run(encoder, run_size);
+#endif
+                return;
+            }
+        }
+#ifdef RLE_STAT
+        encode_channel_run(encoder, channel, run_size);
+#else
+        encode_run(encoder, run_size);
+#endif
+        stopidx = i + channel->state.waitcnt;
+#endif
+    }
+}
+
+static void FNAME(compress_row)(Encoder *encoder, Channel *channel,
+                                const PIXEL * const prev_row,
+                                const PIXEL * const cur_row,
+                                unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
+        if (channel->state.wmileft) {
+            FNAME(compress_row_seg)(encoder, channel, pos, prev_row, cur_row,
+                                    pos + channel->state.wmileft, bppmask[channel->state.wmidx],
+                                    bpc, bpc_mask);
+            width -= channel->state.wmileft;
+            pos += channel->state.wmileft;
+        }
+
+        channel->state.wmidx++;
+        set_wm_trigger(&channel->state);
+        channel->state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(compress_row_seg)(encoder, channel, pos, prev_row, cur_row, pos + width,
+                                bppmask[channel->state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)channel->state.wmidx) {
+            channel->state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
+    ASSERT(encoder->usr, channel->state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+static void FNAME(uncompress_row0_seg)(Encoder *encoder, Channel *channel, int i,
+                                       BYTE * const correlate_row,
+                                       PIXEL * const cur_row,
+                                       const int end,
+                                       const unsigned int waitmask,
+                                       const unsigned int bpc,
+                                       const unsigned int bpc_mask)
+{
+    int stopidx;
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (i == 0) {
+        unsigned int codewordlen;
+
+        correlate_row[0] = (BYTE)golomb_decoding(find_bucket(channel,
+                                                             correlate_row[-1])->bestcode,
+                                                 encoder->io_word, &codewordlen);
+        cur_row[0].a = (BYTE)family.xlatL2U[correlate_row[0]];
+        decode_eatbits(encoder, codewordlen);
+
+        if (channel->state.waitcnt) {
+            --channel->state.waitcnt;
+        } else {
+            channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
+            update_model(&channel->state, find_bucket(channel, correlate_row[-1]),
+                         correlate_row[0], bpc);
+        }
+        stopidx = ++i + channel->state.waitcnt;
+    } else {
+        stopidx = i + channel->state.waitcnt;
+    }
+
+    while (stopidx < end) {
+        struct s_bucket * pbucket = NULL;
+
+        for (; i <= stopidx; i++) {
+            unsigned int codewordlen;
+
+            pbucket = find_bucket(channel, correlate_row[i - 1]);
+            correlate_row[i] = (BYTE)golomb_decoding(pbucket->bestcode, encoder->io_word,
+                                                     &codewordlen);
+            FNAME(corelate_0)(&cur_row[i], correlate_row[i], bpc_mask);
+            decode_eatbits(encoder, codewordlen);
+        }
+
+        update_model(&channel->state, pbucket, correlate_row[stopidx], bpc);
+
+        stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
+    }
+
+    for (; i < end; i++) {
+        unsigned int codewordlen;
+
+        correlate_row[i] = (BYTE)golomb_decoding(find_bucket(channel,
+                                                             correlate_row[i - 1])->bestcode,
+                                                 encoder->io_word, &codewordlen);
+        FNAME(corelate_0)(&cur_row[i], correlate_row[i], bpc_mask);
+        decode_eatbits(encoder, codewordlen);
+    }
+    channel->state.waitcnt = stopidx - end;
+}
+
+static void FNAME(uncompress_row0)(Encoder *encoder, Channel *channel,
+                                   PIXEL * const cur_row,
+                                   unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    BYTE * const correlate_row = channel->correlate_row;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
+        if (channel->state.wmileft) {
+            FNAME(uncompress_row0_seg)(encoder, channel, pos, correlate_row, cur_row,
+                                       pos + channel->state.wmileft, bppmask[channel->state.wmidx],
+                                       bpc, bpc_mask);
+            pos += channel->state.wmileft;
+            width -= channel->state.wmileft;
+        }
+
+        channel->state.wmidx++;
+        set_wm_trigger(&channel->state);
+        channel->state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(uncompress_row0_seg)(encoder, channel, pos, correlate_row, cur_row, pos + width,
+                                   bppmask[channel->state.wmidx], bpc, bpc_mask);
+        if (wmimax > (int)channel->state.wmidx) {
+            channel->state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
+    ASSERT(encoder->usr, channel->state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+static void FNAME(uncompress_row_seg)(Encoder *encoder, Channel *channel,
+                                      BYTE *correlate_row,
+                                      const PIXEL * const prev_row,
+                                      PIXEL * const cur_row,
+                                      int i,
+                                      const int end,
+                                      const unsigned int bpc,
+                                      const unsigned int bpc_mask)
+{
+    const unsigned int waitmask = bppmask[channel->state.wmidx];
+    int stopidx;
+#ifdef RLE
+    int run_index = 0;
+    int run_end;
+#endif
+
+    ASSERT(encoder->usr, end - i > 0);
+
+    if (i == 0) {
+        unsigned int codewordlen;
+
+        correlate_row[0] = (BYTE)golomb_decoding(find_bucket(channel, correlate_row[-1])->bestcode,
+                                                             encoder->io_word, &codewordlen);
+        cur_row[0].a = (family.xlatL2U[correlate_row[0]] + prev_row[0].a) & bpc_mask;
+        decode_eatbits(encoder, codewordlen);
+
+        if (channel->state.waitcnt) {
+            --channel->state.waitcnt;
+        } else {
+            channel->state.waitcnt = (tabrand(&channel->state.tabrand_seed) & waitmask);
+            update_model(&channel->state, find_bucket(channel, correlate_row[-1]),
+                         correlate_row[0], bpc);
+        }
+        stopidx = ++i + channel->state.waitcnt;
+    } else {
+        stopidx = i + channel->state.waitcnt;
+    }
+    for (;;) {
+        while (stopidx < end) {
+            struct s_bucket * pbucket = NULL;
+
+            for (; i <= stopidx; i++) {
+                unsigned int codewordlen;
+#ifdef RLE
+                RLE_PRED_1_IMP;
+                RLE_PRED_2_IMP;
+                RLE_PRED_3_IMP;
+#endif
+                pbucket = find_bucket(channel, correlate_row[i - 1]);
+                correlate_row[i] = (BYTE)golomb_decoding(pbucket->bestcode, encoder->io_word,
+                                                         &codewordlen);
+                FNAME(corelate)(&prev_row[i], &cur_row[i], correlate_row[i], bpc_mask);
+                decode_eatbits(encoder, codewordlen);
+            }
+
+            update_model(&channel->state, pbucket, correlate_row[stopidx], bpc);
+
+            stopidx = i + (tabrand(&channel->state.tabrand_seed) & waitmask);
+        }
+
+        for (; i < end; i++) {
+            unsigned int codewordlen;
+#ifdef RLE
+            RLE_PRED_1_IMP;
+            RLE_PRED_2_IMP;
+            RLE_PRED_3_IMP;
+#endif
+            correlate_row[i] = (BYTE)golomb_decoding(find_bucket(channel,
+                                                                 correlate_row[i - 1])->bestcode,
+                                                     encoder->io_word, &codewordlen);
+            FNAME(corelate)(&prev_row[i], &cur_row[i], correlate_row[i], bpc_mask);
+            decode_eatbits(encoder, codewordlen);
+        }
+
+        channel->state.waitcnt = stopidx - end;
+
+        return;
+
+#ifdef RLE
+do_run:
+        channel->state.waitcnt = stopidx - i;
+        run_index = i;
+#ifdef RLE_STAT
+        run_end = i + decode_channel_run(encoder, channel);
+#else
+        run_end = i + decode_run(encoder);
+#endif
+
+        for (; i < run_end; i++) {
+            cur_row[i].a = cur_row[i - 1].a;
+        }
+
+        if (i == end) {
+            return;
+        }
+
+        stopidx = i + channel->state.waitcnt;
+#endif
+    }
+}
+
+static void FNAME(uncompress_row)(Encoder *encoder, Channel *channel,
+                                  const PIXEL * const prev_row,
+                                  PIXEL * const cur_row,
+                                  unsigned int width)
+
+{
+    const unsigned int bpc = BPC;
+    const unsigned int bpc_mask = BPC_MASK;
+    BYTE * const correlate_row = channel->correlate_row;
+    unsigned int pos = 0;
+
+    while ((wmimax > (int)channel->state.wmidx) && (channel->state.wmileft <= width)) {
+        if (channel->state.wmileft) {
+            FNAME(uncompress_row_seg)(encoder, channel, correlate_row, prev_row, cur_row, pos,
+                                      pos + channel->state.wmileft, bpc, bpc_mask);
+            pos += channel->state.wmileft;
+            width -= channel->state.wmileft;
+        }
+
+        channel->state.wmidx++;
+        set_wm_trigger(&channel->state);
+        channel->state.wmileft = wminext;
+    }
+
+    if (width) {
+        FNAME(uncompress_row_seg)(encoder, channel, correlate_row, prev_row, cur_row, pos,
+                                  pos + width, bpc, bpc_mask);
+        if (wmimax > (int)channel->state.wmidx) {
+            channel->state.wmileft -= width;
+        }
+    }
+
+    ASSERT(encoder->usr, (int)channel->state.wmidx <= wmimax);
+    ASSERT(encoder->usr, channel->state.wmidx <= 32);
+    ASSERT(encoder->usr, wminext > 0);
+}
+
+#undef PIXEL
+#undef FNAME
+#undef _PIXEL_A
+#undef _PIXEL_B
+#undef _PIXEL_C
+#undef RLE_PRED_1_IMP
+#undef RLE_PRED_2_IMP
+#undef RLE_PRED_3_IMP
+#undef golomb_coding
+#undef golomb_deoding
+#undef update_model
+#undef find_bucket
+#undef family
+#undef BPC
+#undef BPC_MASK
+
diff --git a/common/qxl_dev.h b/common/qxl_dev.h
new file mode 100644
index 00000000..bb8c7cb0
--- /dev/null
+++ b/common/qxl_dev.h
@@ -0,0 +1,332 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#ifndef _H_QXL_DEV
+#define _H_QXL_DEV
+
+#include "ipc_ring.h"
+#include "draw.h"
+
+#ifdef __GNUC__
+#ifdef __i386__
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory")
+#else
+//mfence
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%rsp)": : :"memory")
+#endif
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#define mb() __asm {lock add [esp], 0}
+#endif
+
+#define REDHAT_PCI_VENDOR_ID 0x1b36
+#define QXL_DEVICE_ID 0x0100 /* 0x100-0x11f reserved for spice */
+#define QXL_REVISION 0x01
+
+#define QXL_ROM_MAGIC (*(UINT32*)"QXRO")
+#define QXL_RAM_MAGIC (*(UINT32*)"QXRA")
+
+enum {
+    QXL_RAM_RANGE_INDEX,
+    QXL_VRAM_RANGE_INDEX,
+    QXL_ROM_RANGE_INDEX,
+    QXL_IO_RANGE_INDEX,
+
+    QXL_PCI_RANGES
+};
+
+enum {
+    QXL_IO_NOTIFY_CMD,
+    QXL_IO_NOTIFY_CURSOR,
+    QXL_IO_UPDATE_AREA,
+    QXL_IO_UPDATE_IRQ,
+    QXL_IO_NOTIFY_OOM,
+    QXL_IO_RESET,
+    QXL_IO_SET_MODE,
+    QXL_IO_LOG,
+
+    QXL_IO_RANGE_SIZE
+};
+
+typedef struct ATTR_PACKED QXLRom {
+    UINT32 magic;
+    UINT32 id;
+    UINT32 update_id;
+    UINT32 compression_level;
+    UINT32 log_level;
+    UINT32 mode;
+    UINT32 modes_offset;
+    UINT32 num_io_pages;
+    UINT32 pages_offset;
+    UINT32 draw_area_offset;
+    UINT32 draw_area_size;
+    UINT32 ram_header_offset;
+    UINT32 mm_clock;
+} QXLRom;
+
+typedef struct ATTR_PACKED QXLMode {
+    UINT32 id;
+    UINT32 x_res;
+    UINT32 y_res;
+    UINT32 bits;
+    UINT32 stride;
+    UINT32 x_mili;
+    UINT32 y_mili;
+    UINT32 orientation;
+} QXLMode;
+
+typedef struct ATTR_PACKED QXLModes {
+    UINT32 n_modes;
+    QXLMode modes[0];
+} QXLModes;
+
+typedef UINT64 PHYSICAL;
+typedef UINT32 QXLFIXED; //fixed 28.4
+
+enum QXLCmdType {
+    QXL_CMD_NOP,
+    QXL_CMD_DRAW,
+    QXL_CMD_UPDATE,
+    QXL_CMD_CURSOR,
+    QXL_CMD_MESSAGE,
+};
+
+typedef struct ATTR_PACKED QXLCommand {
+    PHYSICAL data;
+    UINT32 type;
+    UINT32 ped;
+} QXLCommand;
+
+
+RING_DECLARE(QXLCommandRing, QXLCommand, 32);
+RING_DECLARE(QXLCursorRing, QXLCommand, 32);
+
+RING_DECLARE(QXLReleaseRing, UINT64, 8);
+
+#define QXL_LOG_BUF_SIZE 4096
+
+#define QXL_INTERRUPT_DISPLAY (1 << 0)
+#define QXL_INTERRUPT_CURSOR (1 << 1)
+
+typedef struct ATTR_PACKED QXLRam {
+    UINT32 magic;
+    UINT32 int_pending;
+    UINT32 int_mask;
+    UINT8 log_buf[QXL_LOG_BUF_SIZE];
+    QXLCommandRing cmd_ring;
+    QXLCursorRing cursor_ring;
+    QXLReleaseRing release_ring;
+    Rect update_area;
+} QXLRam;
+
+typedef union QXLReleaseInfo {
+    UINT64 id;      // in
+    UINT64 next;    // out
+} QXLReleaseInfo;
+
+typedef struct  ATTR_PACKED QXLDataChunk {
+    UINT32 data_size;
+    PHYSICAL prev_chunk;
+    PHYSICAL next_chunk;
+    UINT8 data[0];
+} QXLDataChunk;
+
+typedef struct ATTR_PACKED QXLMessage {
+    QXLReleaseInfo release_info;
+    UINT8 data[0];
+} QXLMessage;
+
+typedef struct ATTR_PACKED QXLUpdateCmd {
+    QXLReleaseInfo release_info;
+    Rect area;
+    UINT32 update_id;
+} QXLUpdateCmd;
+
+typedef struct ATTR_PACKED QXLCursor {
+    CursorHeader header;
+    UINT32 data_size;
+    QXLDataChunk chunk;
+} QXLCursor;
+
+enum {
+    QXL_CURSOR_SET,
+    QXL_CURSOR_MOVE,
+    QXL_CURSOR_HIDE,
+    QXL_CURSOR_TRAIL,
+};
+
+#define QXL_CURSUR_DEVICE_DATA_SIZE 128
+
+typedef struct ATTR_PACKED QXLCursorCmd {
+    QXLReleaseInfo release_info;
+    UINT8 type;
+    union {
+        struct ATTR_PACKED {
+            Point16 position;
+            UINT8 visible;
+            PHYSICAL shape;
+        } set;
+        struct ATTR_PACKED {
+            UINT16 length;
+            UINT16 frequency;
+        } trail;
+        Point16 position;
+    } u;
+    UINT8 device_data[QXL_CURSUR_DEVICE_DATA_SIZE]; //todo: dynamic size from rom
+} QXLCursorCmd;
+
+enum {
+    QXL_DRAW_NOP,
+    QXL_DRAW_FILL,
+    QXL_DRAW_OPAQUE,
+    QXL_DRAW_COPY,
+    QXL_COPY_BITS,
+    QXL_DRAW_BLEND,
+    QXL_DRAW_BLACKNESS,
+    QXL_DRAW_WHITENESS,
+    QXL_DRAW_INVERS,
+    QXL_DRAW_ROP3,
+    QXL_DRAW_STROKE,
+    QXL_DRAW_TEXT,
+    QXL_DRAW_TRANSPARENT,
+    QXL_DRAW_ALPHA_BLEND,
+};
+
+typedef struct ATTR_PACKED QXLString {
+    UINT32 data_size;
+    UINT16 length;
+    UINT16 flags;
+    QXLDataChunk chunk;
+} QXLString;
+
+typedef struct ATTR_PACKED QXLCopyBits {
+    Point src_pos;
+} QXLCopyBits;
+
+#define QXL_EFFECT_BLEND 0
+#define QXL_EFFECT_OPAQUE 1
+#define QXL_EFFECT_REVERT_ON_DUP 2
+#define QXL_EFFECT_BLACKNESS_ON_DUP 3
+#define QXL_EFFECT_WHITENESS_ON_DUP 4
+#define QXL_EFFECT_NOP_ON_DUP 5
+#define QXL_EFFECT_NOP 6
+#define QXL_EFFECT_OPAQUE_BRUSH 7
+
+typedef struct ATTR_PACKED QXLDrawable {
+    QXLReleaseInfo release_info;
+    UINT8 effect;
+    UINT8 type;
+    UINT16 bitmap_offset;
+    Rect bitmap_area;
+    Rect bbox;
+    Clip clip;
+    UINT32 mm_time;
+    union {
+        Fill fill;
+        Opaque opaque;
+        Copy copy;
+        Transparent transparent;
+        AlphaBlnd alpha_blend;
+        QXLCopyBits copy_bits;
+        Blend blend;
+        Rop3 rop3;
+        Stroke stroke;
+        Text text;
+        Blackness blackness;
+        Invers invers;
+        Whiteness whiteness;
+    } u;
+} QXLDrawable;
+
+typedef struct ATTR_PACKED QXLClipRects {
+    UINT32 num_rects;
+    QXLDataChunk chunk;
+} QXLClipRects;
+
+enum {
+    QXL_PATH_BEGIN = (1 << 0),
+    QXL_PATH_END = (1 << 1),
+    QXL_PATH_CLOSE = (1 << 3),
+    QXL_PATH_BEZIER = (1 << 4),
+};
+
+typedef struct ATTR_PACKED QXLPath {
+    UINT32 data_size;
+    QXLDataChunk chunk;
+} QXLPath;
+
+enum {
+    QXL_IMAGE_GROUP_DRIVER,
+    QXL_IMAGE_GROUP_DEVICE,
+    QXL_IMAGE_GROUP_RED,
+    QXL_IMAGE_GROUP_DRIVER_DONT_CACHE,
+};
+
+typedef struct ATTR_PACKED QXLImageID {
+    UINT32 group;
+    UINT32 unique;
+} QXLImageID;
+
+enum {
+    QXL_IMAGE_CACHE = (1 << 0),
+};
+
+enum {
+    QXL_BITMAP_DIRECT = (1 << 0),
+    QXL_BITMAP_UNSTABLE = (1 << 1),
+    QXL_BITMAP_TOP_DOWN = (1 << 2), // == BITMAP_TOP_DOWN
+};
+
+#define QXL_SET_IMAGE_ID(image, _group, _unique) {              \
+    UINT64* id_ptr = &(image)->descriptor.id;                   \
+    QXLImageID *image_id = (QXLImageID *)id_ptr;                \
+    image_id->group = _group;                                   \
+    image_id->unique = _unique;                                 \
+}
+
+typedef struct ATTR_PACKED QXLImage {
+    ImageDescriptor descriptor;
+    union { // variable length
+        Bitmap bitmap;
+        QUICData quic;
+    };
+} QXLImage;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#endif
diff --git a/common/rect.h b/common/rect.h
new file mode 100644
index 00000000..569b530a
--- /dev/null
+++ b/common/rect.h
@@ -0,0 +1,116 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RECT
+#define _H_RECT
+
+#include "draw.h"
+
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+
+static inline void rect_sect(Rect* r, const Rect* bounds)
+{
+    r->left = MAX(r->left, bounds->left);
+    r->right = MIN(r->right, bounds->right);
+    r->right = MAX(r->left, r->right);
+
+    r->top = MAX(r->top, bounds->top);
+    r->bottom = MIN(r->bottom, bounds->bottom);
+    r->bottom = MAX(r->top, r->bottom);
+}
+
+static inline void rect_offset(Rect* r, int dx, int dy)
+{
+    r->left += dx;
+    r->right += dx;
+    r->top += dy;
+    r->bottom += dy;
+}
+
+static inline int rect_is_empty(const Rect* r)
+{
+    return r->top == r->bottom || r->left == r->right;
+}
+
+static inline int rect_intersects(const Rect* r1, const Rect* r2)
+{
+    return r1->left < r2->right && r1->right > r2->left &&
+           r1->top < r2->bottom && r1->bottom > r2->top;
+}
+
+static inline int rect_is_equal(const Rect *r1, const Rect *r2)
+{
+    return r1->top == r2->top && r1->left == r2->left &&
+           r1->bottom == r2->bottom && r1->right == r2->right;
+}
+
+static inline void rect_union(Rect *dest, const Rect *r)
+{
+    dest->top = MIN(dest->top, r->top);
+    dest->left = MIN(dest->left, r->left);
+    dest->bottom = MAX(dest->bottom, r->bottom);
+    dest->right = MAX(dest->right, r->right);
+}
+
+static inline int rect_is_same_size(const Rect *r1, const Rect *r2)
+{
+    return r1->right - r1->left == r2->right - r2->left &&
+           r1->bottom - r1->top == r2->bottom - r2->top;
+}
+
+#ifdef __cplusplus
+
+static inline void rect_sect(Rect& r, const Rect& bounds)
+{
+    rect_sect(&r, &bounds);
+}
+
+static inline void rect_offset(Rect& r, int dx, int dy)
+{
+    rect_offset(&r, dx, dy);
+}
+
+static inline int rect_is_empty(const Rect& r)
+{
+    return rect_is_empty(&r);
+}
+
+static inline int rect_intersects(const Rect& r1, const Rect& r2)
+{
+    return rect_intersects(&r1, &r2);
+}
+
+static inline int rect_is_equal(const Rect& r1, const Rect& r2)
+{
+    return rect_is_equal(&r1, &r2);
+}
+
+static inline void rect_union(Rect& dest, const Rect& r)
+{
+    rect_union(&dest, &r);
+}
+
+static inline int rect_is_same_size(const Rect& r1, const Rect& r2)
+{
+    return rect_is_same_size(&r1, &r2);
+}
+
+#endif
+
+#endif
+
diff --git a/common/red.h b/common/red.h
new file mode 100644
index 00000000..4b0a3642
--- /dev/null
+++ b/common/red.h
@@ -0,0 +1,685 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_RED
+#define _H_RED
+
+#include <stdint.h>
+#ifdef _WIN32
+#include <basetsd.h>
+#endif
+#include "draw.h"
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#endif
+
+#define RED_MAGIC (*(uint32_t*)"REDQ")
+#define RED_VERSION_MAJOR 1
+#define RED_VERSION_MINOR 0
+
+// Encryption & Ticketing Parameters
+#define RED_MAX_PASSWORD_LENGTH 60
+#define RED_TICKET_KEY_PAIR_LENGTH 1024
+#define RED_TICKET_PUBKEY_BYTES (RED_TICKET_KEY_PAIR_LENGTH / 8 + 34)
+
+enum {
+    RED_CHANNEL_MAIN = 1,
+    RED_CHANNEL_DISPLAY,
+    RED_CHANNEL_INPUTS,
+    RED_CHANNEL_CURSOR,
+    RED_CHANNEL_PLAYBACK,
+    RED_CHANNEL_RECORD,
+
+    RED_CHANNEL_END
+};
+
+enum {
+    RED_ERR_OK,
+    RED_ERR_ERROR,
+    RED_ERR_INVALID_MAGIC,
+    RED_ERR_INVALID_DATA,
+    RED_ERR_VERSION_MISMATCH,
+    RED_ERR_NEED_SECURED,
+    RED_ERR_NEED_UNSECURED,
+    RED_ERR_PERMISSION_DENIED,
+    RED_ERR_BAD_CONNECTION_ID,
+    RED_ERR_CHANNEL_NOT_AVAILABLE,
+};
+
+enum {
+    RED_WARN_GENERAL,
+};
+
+enum {
+    RED_INFO_GENERAL,
+};
+
+typedef struct ATTR_PACKED RedLinkHeader {
+    uint32_t magic;
+    uint32_t major_version;
+    uint32_t minor_version;
+    uint32_t size;
+} RedLinkHeader;
+
+typedef struct ATTR_PACKED RedLinkMess {
+    uint32_t connection_id;
+    uint8_t channel_type;
+    uint8_t channel_id;
+    uint32_t num_common_caps;
+    uint32_t num_channel_caps;
+    uint32_t caps_offset;
+} RedLinkMess;
+
+typedef struct ATTR_PACKED RedLinkReply {
+    uint32_t error;
+    uint8_t pub_key[RED_TICKET_PUBKEY_BYTES];
+    uint32_t num_common_caps;
+    uint32_t num_channel_caps;
+    uint32_t caps_offset;
+} RedLinkReply;
+
+typedef struct ATTR_PACKED RedLinkEncryptedTicket {
+    uint8_t encrypted_data[RED_TICKET_KEY_PAIR_LENGTH / 8];
+} RedLinkEncryptedTicket;
+
+typedef struct ATTR_PACKED RedDataHeader {
+    uint64_t serial;
+    uint16_t type;
+    uint32_t size;
+    uint32_t sub_list; //offset to RedSubMessageList[]
+} RedDataHeader;
+
+typedef struct ATTR_PACKED RedSubMessage {
+    uint16_t type;
+    uint32_t size;
+} RedSubMessage;
+
+typedef struct ATTR_PACKED RedSubMessageList {
+    uint16_t size;
+    uint32_t sub_messages[0]; //offsets to RedSubMessage
+} RedSubMessageList;
+
+enum {
+    RED_MIGRATE = 1,
+    RED_MIGRATE_DATA,
+    RED_SET_ACK,
+    RED_PING,
+    RED_WAIT_FOR_CHANNELS,
+    RED_DISCONNECTING,
+    RED_NOTIFY,
+
+    RED_FIRST_AVAIL_MESSAGE = 101
+};
+
+enum {
+    REDC_ACK_SYNC = 1,
+    REDC_ACK,
+    REDC_PONG,
+    REDC_MIGRATE_FLUSH_MARK,
+    REDC_MIGRATE_DATA,
+    REDC_DISCONNECTING,
+
+    REDC_FIRST_AVAIL_MESSAGE = 101,
+};
+
+enum {
+    RED_MIGRATE_BEGIN = RED_FIRST_AVAIL_MESSAGE,
+    RED_MIGRATE_CANCEL,
+    RED_INIT,
+    RED_CHANNELS_LIST,
+    RED_MOUSE_MODE,
+    RED_MULTI_MEDIA_TIME,
+
+    RED_AGENT_CONNECTED,
+    RED_AGENT_DISCONNECTED,
+    RED_AGENT_DATA,
+    RED_AGENT_TOKEN,
+
+    RED_MESSAGES_END,
+};
+
+enum {
+    REDC_CLIENT_INFO = REDC_FIRST_AVAIL_MESSAGE,
+    REDC_MIGRATE_CONNECTED,
+    REDC_MIGRATE_CONNECT_ERROR,
+    REDC_ATTACH_CHANNELS,
+    REDC_MOUSE_MODE_REQUEST,
+
+    REDC_AGENT_START,
+    REDC_AGENT_DATA,
+    REDC_AGENT_TOKEN,
+};
+
+#define RED_MOTION_ACK_BUNCH 4
+
+enum {
+    RED_INPUTS_INIT = RED_FIRST_AVAIL_MESSAGE,
+    RED_INPUTS_KEY_MODIFAIERS,
+
+    RED_INPUTS_MOUSE_MOTION_ACK = RED_FIRST_AVAIL_MESSAGE + 10,
+
+    RED_INPUTS_MESSAGES_END,
+};
+
+#define RED_SCROLL_LOCK_MODIFIER (1 << 0)
+#define RED_NUM_LOCK_MODIFIER (1 << 1)
+#define RED_CAPS_LOCK_MODIFIER (1 << 2)
+
+typedef struct ATTR_PACKED RedInputsInit {
+    uint32_t keyboard_modifiers;
+} RedInputsInit;
+
+typedef struct ATTR_PACKED RedKeyModifiers {
+    uint32_t modifiers;
+} RedKeyModifiers;
+
+typedef struct ATTR_PACKED RedMultiMediaTime {
+    uint32_t time;
+} RedMultiMediaTime;
+
+typedef struct ATTR_PACKED RedMigrationBegin {
+    uint16_t port;
+    uint16_t sport;
+    char host[0];
+} RedMigrationBegin;
+
+enum {
+    RED_MIGRATE_NEED_FLUSH = (1 << 0),
+    RED_MIGRATE_NEED_DATA_TRANSFER = (1 << 1),
+};
+
+typedef struct ATTR_PACKED RedMigrate {
+    uint32_t flags;
+} RedMigrate;
+
+enum {
+    RED_RES_TYPE_INVALID,
+    RED_RES_TYPE_PIXMAP,
+};
+
+typedef struct ATTR_PACKED RedResorceID {
+    uint8_t type;
+    uint64_t id;
+} RedResorceID;
+
+typedef struct ATTR_PACKED RedResorceList {
+    uint16_t count;
+    RedResorceID resorces[0];
+} RedResorceList;
+
+typedef struct ATTR_PACKED RedSetAck {
+    uint32_t generation;
+    uint32_t window;
+} RedSetAck;
+
+typedef struct ATTR_PACKED RedWaitForChannel {
+    uint8_t channel_type;
+    uint8_t channel_id;
+    uint64_t message_serial;
+} RedWaitForChannel;
+
+typedef struct ATTR_PACKED RedWaitForChannels {
+    uint8_t wait_count;
+    RedWaitForChannel wait_list[0];
+} RedWaitForChannels;
+
+typedef struct ATTR_PACKED RedChannelInit {
+    uint8_t type;
+    uint8_t id;
+} RedChannelInit;
+
+typedef struct ATTR_PACKED RedInit {
+    uint32_t session_id;
+    uint32_t display_channels_hint;
+    uint32_t supported_mouse_modes;
+    uint32_t current_mouse_mode;
+    uint32_t agent_connected;
+    uint32_t agent_tokens;
+    uint32_t multi_media_time;
+    uint32_t ram_hint;
+} RedInit;
+
+typedef struct ATTR_PACKED RedDisconnect {
+    uint64_t time_stamp;
+    uint32_t reason; // RED_ERR_?
+} RedDisconnect;
+
+enum {
+    RED_NOTIFY_SEVERITY_INFO,
+    RED_NOTIFY_SEVERITY_WARN,
+    RED_NOTIFY_SEVERITY_ERROR,
+};
+
+enum {
+    RED_NOTIFY_VISIBILITY_LOW,
+    RED_NOTIFY_VISIBILITY_MEDIUM,
+    RED_NOTIFY_VISIBILITY_HIGH,
+};
+
+typedef struct ATTR_PACKED RedNotify {
+    uint64_t time_stamp;
+    uint32_t severty;
+    uint32_t visibilty;
+    uint32_t what;
+    uint32_t message_len;
+    uint8_t message[0];
+} RedNotify;
+
+typedef struct ATTR_PACKED RedChannels {
+    uint32_t num_of_channels;
+    RedChannelInit channels[0];
+} RedChannels;
+
+typedef struct ATTR_PACKED RedMouseMode {
+    uint32_t supported_modes;
+    uint32_t current_mode;
+} RedMouseMode;
+
+typedef struct ATTR_PACKED RedPing {
+    uint32_t id;
+    uint64_t timestamp;
+} RedPing;
+
+typedef struct ATTR_PACKED RedAgentDisconnect {
+    uint32_t error_code; // RED_ERR_?
+} RedAgentDisconnect;
+
+#define RED_AGENT_MAX_DATA_SIZE 2048
+
+typedef struct ATTR_PACKED RedAgentTokens {
+    uint32_t num_tokens;
+} RedAgentTokens, RedcAgentTokens, RedcAgentStart;
+
+typedef struct ATTR_PACKED RedcClientInfo {
+    uint64_t cache_size;
+} RedcClientInfo;
+
+typedef struct ATTR_PACKED RedcMouseModeRequest {
+    uint32_t mode;
+} RedcMouseModeRequest;
+
+enum {
+    RED_DISPLAY_MODE = RED_FIRST_AVAIL_MESSAGE,
+    RED_DISPLAY_MARK,
+    RED_DISPLAY_RESET,
+    RED_DISPLAY_COPY_BITS,
+
+    RED_DISPLAY_INVAL_LIST,
+    RED_DISPLAY_INVAL_ALL_PIXMAPS,
+    RED_DISPLAY_INVAL_PALETTE,
+    RED_DISPLAY_INVAL_ALL_PALETTES,
+
+    RED_DISPLAY_STREAM_CREATE = RED_FIRST_AVAIL_MESSAGE + 21,
+    RED_DISPLAY_STREAM_DATA,
+    RED_DISPLAY_STREAM_CLIP,
+    RED_DISPLAY_STREAM_DESTROY,
+    RED_DISPLAY_STREAM_DESTROY_ALL,
+
+    RED_DISPLAY_DRAW_FILL = RED_FIRST_AVAIL_MESSAGE + 201,
+    RED_DISPLAY_DRAW_OPAQUE,
+    RED_DISPLAY_DRAW_COPY,
+    RED_DISPLAY_DRAW_BLEND,
+    RED_DISPLAY_DRAW_BLACKNESS,
+    RED_DISPLAY_DRAW_WHITENESS,
+    RED_DISPLAY_DRAW_INVERS,
+    RED_DISPLAY_DRAW_ROP3,
+    RED_DISPLAY_DRAW_STROKE,
+    RED_DISPLAY_DRAW_TEXT,
+    RED_DISPLAY_DRAW_TRANSPARENT,
+    RED_DISPLAY_DRAW_ALPHA_BLEND,
+
+    RED_DISPLAY_MESSAGES_END,
+};
+
+enum {
+    RED_CURSOR_NONE = (1 << 0),
+    RED_CURSOR_CACHE_ME = (1 << 1),
+    RED_CURSOR_FROM_CACHE = (1 << 2),
+};
+
+typedef struct ATTR_PACKED RedCursor {
+    uint32_t flags;
+    CursorHeader header;
+    uint8_t data[0];
+} RedCursor;
+
+typedef struct ATTR_PACKED RedMode {
+    uint32_t x_res;
+    uint32_t y_res;
+    uint32_t bits;
+} RedMode;
+
+typedef struct ATTR_PACKED RedDrawBase {
+    Rect box;
+    Clip clip;
+} RedDrawBase;
+
+typedef struct ATTR_PACKED RedFill {
+    RedDrawBase base;
+    Fill data;
+} RedFill;
+
+typedef struct ATTR_PACKED RedOpaque {
+    RedDrawBase base;
+    Opaque data;
+} RedOpaque;
+
+typedef struct ATTR_PACKED RedCopy {
+    RedDrawBase base;
+    Copy data;
+} RedCopy;
+
+typedef struct ATTR_PACKED RedTransparent {
+    RedDrawBase base;
+    Transparent data;
+} RedTransparent;
+
+typedef struct ATTR_PACKED RedAlphaBlend {
+    RedDrawBase base;
+    AlphaBlnd data;
+} RedAlphaBlend;
+
+typedef struct ATTR_PACKED RedCopyBits {
+    RedDrawBase base;
+    Point src_pos;
+} RedCopyBits;
+
+typedef RedCopy RedBlend;
+
+typedef struct ATTR_PACKED RedRop3 {
+    RedDrawBase base;
+    Rop3 data;
+} RedRop3;
+
+typedef struct ATTR_PACKED RedBlackness {
+    RedDrawBase base;
+    Blackness data;
+} RedBlackness;
+
+typedef struct ATTR_PACKED RedWhiteness {
+    RedDrawBase base;
+    Whiteness data;
+} RedWhiteness;
+
+typedef struct ATTR_PACKED RedInvers {
+    RedDrawBase base;
+    Invers data;
+} RedInvers;
+
+typedef struct ATTR_PACKED RedStroke {
+    RedDrawBase base;
+    Stroke data;
+} RedStroke;
+
+typedef struct ATTR_PACKED RedText {
+    RedDrawBase base;
+    Text data;
+} RedText;
+
+typedef struct ATTR_PACKED RedInvalOne {
+    uint64_t id;
+} RedInvalOne;
+
+enum {
+    RED_VIDEO_CODEC_TYPE_MJPEG = 1,
+};
+
+enum {
+    STREAM_TOP_DOWN = (1 << 0),
+};
+
+typedef struct ATTR_PACKED RedStreamCreate {
+    uint32_t id;
+    uint32_t flags;
+    uint32_t codec_type;
+    uint64_t stamp;
+    uint32_t stream_width;
+    uint32_t stream_height;
+    uint32_t src_width;
+    uint32_t src_height;
+    Rect dest;
+    Clip clip;
+} RedStreamCreate;
+
+typedef struct ATTR_PACKED RedStreamData {
+    uint32_t id;
+    uint32_t multi_media_time;
+    uint32_t data_size;
+    uint32_t ped_size;
+    uint8_t data[0];
+} RedStreamData;
+
+typedef struct ATTR_PACKED RedStreamClip {
+    uint32_t id;
+    Clip clip;
+} RedStreamClip;
+
+typedef struct ATTR_PACKED RedStreamDestroy {
+    uint32_t id;
+} RedStreamDestroy;
+
+enum {
+    RED_CURSOR_INIT = RED_FIRST_AVAIL_MESSAGE,
+    RED_CURSOR_RESET,
+    RED_CURSOR_SET,
+    RED_CURSOR_MOVE,
+    RED_CURSOR_HIDE,
+    RED_CURSOR_TRAIL,
+    RED_CURSOR_INVAL_ONE,
+    RED_CURSOR_INVAL_ALL,
+
+    RED_CURSOR_MESSAGES_END,
+};
+
+typedef struct ATTR_PACKED RedCursorInit {
+    Point16 position;
+    uint16_t trail_length;
+    uint16_t trail_frequency;
+    uint8_t visible;
+    RedCursor cursor;
+} RedCursorInit;
+
+typedef struct ATTR_PACKED RedCursorSet {
+    Point16 postition;
+    uint8_t visible;
+    RedCursor cursor;
+} RedCursorSet;
+
+typedef struct ATTR_PACKED RedCursorMove {
+    Point16 postition;
+} RedCursorMove;
+
+typedef struct ATTR_PACKED RedCursorTrail {
+    uint16_t length;
+    uint16_t frequency;
+} RedCursorTrail;
+
+enum {
+    REDC_DISPLAY_INIT = REDC_FIRST_AVAIL_MESSAGE,
+
+    REDC_DISPLAY_MESSGES_END,
+};
+
+typedef struct ATTR_PACKED RedcDisplayInit {
+    uint8_t pixmap_cache_id;
+    int64_t pixmap_cache_size; //in pixels
+    uint8_t glz_dictionary_id;
+    int glz_dictionary_window_size;       // in pixels
+} RedcDisplayInit;
+
+enum {
+    REDC_INPUTS_KEY_DOWN = REDC_FIRST_AVAIL_MESSAGE,
+    REDC_INPUTS_KEY_UP,
+    REDC_INPUTS_KEY_MODIFAIERS,
+
+    REDC_INPUTS_MOUSE_MOTION = REDC_FIRST_AVAIL_MESSAGE + 10,
+    REDC_INPUTS_MOUSE_POSITION,
+    REDC_INPUTS_MOUSE_PRESS,
+    REDC_INPUTS_MOUSE_RELEASE,
+
+    REDC_INPUTS_MESSGES_END,
+};
+
+typedef struct ATTR_PACKED RedcKeyDown {
+    uint32_t code;
+} RedcKeyDown;
+
+typedef struct ATTR_PACKED RedcKeyUp {
+    uint32_t code;
+} RedcKeyUp;
+
+enum {
+    RED_MOUSE_MODE_SERVER = (1 << 0),
+    RED_MOUSE_MODE_CLIENT = (1 << 1),
+};
+
+typedef struct ATTR_PACKED RedcKeyModifiers {
+    uint32_t modifiers;
+} RedcKeyModifiers;
+
+enum RedButton {
+    REDC_MOUSE_INVALID_BUTTON,
+    REDC_MOUSE_LBUTTON,
+    REDC_MOUSE_MBUTTON,
+    REDC_MOUSE_RBUTTON,
+    REDC_MOUSE_UBUTTON,
+    REDC_MOUSE_DBUTTON,
+};
+
+#define REDC_LBUTTON_MASK (1 << (REDC_MOUSE_LBUTTON - 1))
+#define REDC_MBUTTON_MASK (1 << (REDC_MOUSE_MBUTTON - 1))
+#define REDC_RBUTTON_MASK (1 << (REDC_MOUSE_RBUTTON - 1))
+
+typedef struct ATTR_PACKED RedcMouseMotion {
+    int32_t dx;
+    int32_t dy;
+    uint32_t buttons_state;
+} RedcMouseMotion;
+
+typedef struct ATTR_PACKED RedcMousePosition {
+    uint32_t x;
+    uint32_t y;
+    uint32_t buttons_state;
+    uint8_t display_id;
+} RedcMousePosition;
+
+typedef struct ATTR_PACKED RedcMousePress {
+    int32_t button;
+    int32_t buttons_state;
+} RedcMousePress;
+
+typedef struct ATTR_PACKED RedcMouseRelease {
+    int32_t button;
+    int32_t buttons_state;
+} RedcMouseRelease;
+
+enum {
+    RED_AUDIO_FMT_INVALD,
+    RED_AUDIO_FMT_S16,
+};
+
+enum {
+    RED_AUDIO_DATA_MODE_INVALD,
+    RED_AUDIO_DATA_MODE_RAW,
+    RED_AUDIO_DATA_MODE_CELT_0_5_1,
+};
+
+enum {
+    RED_PLAYBACK_DATA = RED_FIRST_AVAIL_MESSAGE,
+    RED_PLAYBACK_MODE,
+    RED_PLAYBACK_START,
+    RED_PLAYBACK_STOP,
+
+    RED_PLAYBACK_MESSAGES_END,
+};
+
+enum {
+    RED_PLAYBACK_CAP_CELT_0_5_1,
+};
+
+enum {
+    RED_RECORD_START = RED_FIRST_AVAIL_MESSAGE,
+    RED_RECORD_STOP,
+
+    RED_RECORD_MESSAGES_END,
+};
+
+enum {
+    REDC_RECORD_DATA = RED_FIRST_AVAIL_MESSAGE,
+    REDC_RECORD_MODE,
+    REDC_RECORD_START_MARK,
+
+    REDC_RECORD_MESSAGES_END,
+};
+
+enum {
+    RED_RECORD_CAP_CELT_0_5_1,
+};
+
+typedef struct ATTR_PACKED RedPlaybackMode {
+    uint32_t time;
+    uint32_t mode; //RED_AUDIO_DATA_MODE_?
+    uint8_t data[0];
+} RedPlaybackMode, RedcRecordMode;
+
+typedef struct ATTR_PACKED RedPlaybackStart {
+    uint32_t channels;
+    uint32_t format; //RED_AUDIO_FMT_?
+    uint32_t frequency;
+    uint32_t time;
+} RedPlaybackStart;
+
+typedef struct ATTR_PACKED RedPlaybackPacket {
+    uint32_t time;
+    uint8_t data[0];
+} RedPlaybackPacket, RedcRecordPacket;
+
+typedef struct ATTR_PACKED RedRecordStart {
+    uint32_t channels;
+    uint32_t format; //RED_AUDIO_FMT_?
+    uint32_t frequency;
+} RedRecordStart;
+
+typedef struct ATTR_PACKED RedcRecordStartMark {
+    uint32_t time;
+} RedcRecordStartMark;
+
+#undef ATTR_PACKED
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#endif
+
diff --git a/common/red_error_codes.h b/common/red_error_codes.h
new file mode 100644
index 00000000..c08fd510
--- /dev/null
+++ b/common/red_error_codes.h
@@ -0,0 +1,50 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef RED_ERROR_CODES_H
+#define RED_ERROR_CODES_H
+
+#define SPICEC_ERROR_CODE_SUCCESS (0)
+#define SPICEC_ERROR_CODE_ERROR (-1)
+#define SPICEC_ERROR_CODE_GETHOSTBYNAME_FAILED (-2)
+#define SPICEC_ERROR_CODE_CONNECT_FAILED (-3)
+#define SPICEC_ERROR_CODE_SOCKET_FAILED (-4)
+#define SPICEC_ERROR_CODE_SEND_FAILED (-5)
+#define SPICEC_ERROR_CODE_RECV_FAILED (-6)
+#define SPICEC_ERROR_CODE_SSL_ERROR (-7)
+#define SPICEC_ERROR_CODE_NOT_ENOUGH_MEMORY (-8)
+#define SPICEC_ERROR_CODE_AGENT_TIMEOUT (-9)
+#define SPICEC_ERROR_CODE_AGENT_ERROR (-10)
+#define SPICEC_ERROR_CODE_VERSION_MISMATCH (-11)
+#define SPICEC_ERROR_CODE_PERMISSION_DENIED (-12)
+#define SPICEC_ERROR_CODE_INVALID_ARG (-13)
+
+#endif
+
diff --git a/common/reds_stat.h b/common/reds_stat.h
new file mode 100644
index 00000000..0baa13f9
--- /dev/null
+++ b/common/reds_stat.h
@@ -0,0 +1,68 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_REDS_STAT
+#define _H_REDS_STAT
+
+#include <stdint.h>
+
+#define REDS_STAT_SHM_NAME "spice.%u"
+#define REDS_STAT_NODE_NAME_MAX_LENGTH 20
+#define REDS_STAT_MAGIC (*(uint32_t*)"STAT")
+#define REDS_STAT_VERSION 1
+
+enum {
+    STAT_NODE_FLAG_ENABLED = (1 << 0),
+    STAT_NODE_FLAG_VISIBLE = (1 << 1),
+    STAT_NODE_FLAG_VALUE = (1 << 2),
+};
+
+#define STAT_NODE_MASK_SHOW (STAT_NODE_FLAG_ENABLED | STAT_NODE_FLAG_VISIBLE)
+#define STAT_NODE_MASK_SHOW_VALUE (STAT_NODE_MASK_SHOW | STAT_NODE_FLAG_VALUE)
+
+typedef struct StatNode {
+    uint64_t value;
+    uint32_t flags;
+    uint32_t next_sibling_index;
+    uint32_t first_child_index;
+    char name[REDS_STAT_NODE_NAME_MAX_LENGTH];
+} StatNode;
+
+typedef struct RedsStat {
+    uint32_t magic;
+    uint32_t version;
+    uint32_t generation;
+    uint32_t num_of_nodes;
+    uint32_t root_index;
+    StatNode nodes[];
+} RedsStat;
+
+#endif
+
diff --git a/common/region.c b/common/region.c
new file mode 100644
index 00000000..d1d7f4a0
--- /dev/null
+++ b/common/region.c
@@ -0,0 +1,1230 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "region.h"
+#include "rect.h"
+
+//#define ALLOC_ON_STEAL
+//#define REGION_DEBUG
+
+#define FALSE 0
+#define TRUE 1
+
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+
+#define ASSERT(x) if (!(x)) {                               \
+    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
+    abort();                                                \
+}
+
+#ifdef REGION_DEBUG
+#define REGION_IS_VALID(region) region_is_valid(region)
+#else
+#define REGION_IS_VALID(region) TRUE
+#endif
+
+static int rect_is_valid(const Rect *r)
+{
+    if (r->top > r->bottom || r->left > r->right) {
+        printf("%s: invalid rect\n", __FUNCTION__);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+#ifdef REGION_TEST
+static void rect_set(Rect *r, int32_t top, int32_t left, int32_t bottom, int32_t right)
+{
+    r->top = top;
+    r->left = left;
+    r->bottom = bottom;
+    r->right = right;
+    ASSERT(rect_is_valid(r));
+}
+
+#endif
+
+static inline void __region_init(QRegion *rgn)
+{
+    rgn->num_rects = 0;
+    rgn->rects = rgn->buf;
+    rgn->rects_size = RECTS_BUF_SIZE;
+}
+
+void region_init(QRegion *rgn)
+{
+    __region_init(rgn);
+    ASSERT(REGION_IS_VALID(rgn));
+}
+
+void region_clear(QRegion *rgn)
+{
+    rgn->num_rects = 0;
+}
+
+void region_destroy(QRegion *rgn)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    if (rgn->rects != rgn->buf) {
+        free(rgn->rects);
+    }
+}
+
+void region_clone(QRegion *dest, const QRegion *src)
+{
+    ASSERT(REGION_IS_VALID(src));
+    dest->bbox = src->bbox;
+    if ((dest->num_rects = src->num_rects) <= RECTS_BUF_SIZE) {
+        dest->rects = dest->buf;
+        dest->rects_size = RECTS_BUF_SIZE;
+    } else {
+        dest->rects = (Rect *)malloc(sizeof(Rect) * dest->num_rects);
+        dest->rects_size = dest->num_rects;
+    }
+    memcpy(dest->rects, src->rects, dest->num_rects * sizeof(Rect));
+    ASSERT(REGION_IS_VALID(src));
+    ASSERT(REGION_IS_VALID(dest));
+}
+
+int region_is_valid(const QRegion *rgn)
+{
+    if (rgn->num_rects) {
+        uint32_t i;
+        Rect bbox;
+
+        if (!rect_is_valid(&rgn->bbox)) {
+            return FALSE;
+        }
+        bbox = rgn->rects[0];
+        if (!rect_is_valid(&bbox) || rect_is_empty(&bbox)) {
+            return FALSE;
+        }
+        for (i = 1; i < rgn->num_rects; i++) {
+            Rect *r;
+
+            r = &rgn->rects[i];
+            if (!rect_is_valid(r) || rect_is_empty(r)) {
+                return FALSE;
+            }
+
+            Rect *priv = r - 1;
+            if (r->top < priv->top) {
+                return FALSE;
+            } else if (r->top == priv->top) {
+                if (r->bottom != priv->bottom) {
+                    return FALSE;
+                }
+                if (r->left < priv->right) {
+                    return FALSE;
+                }
+            } else if (priv->bottom > r->top) {
+                return FALSE;
+            }
+            bbox.top = MIN(bbox.top, r->top);
+            bbox.left = MIN(bbox.left, r->left);
+            bbox.bottom = MAX(bbox.bottom, r->bottom);
+            bbox.right = MAX(bbox.right, r->right);
+        }
+        return rect_is_equal(&bbox, &rgn->bbox);
+    }
+    return TRUE;
+}
+
+void region_dump(const QRegion *rgn, const char *prefix)
+{
+    char *indent;
+    int len;
+    uint32_t i;
+
+    len = strlen(prefix);
+    if (!(indent = (char *)malloc(len + 1))) {
+        printf("%s: malloc failed\n", __FUNCTION__);
+        return;
+    }
+    memset(indent, ' ', len);
+    indent[len] = 0;
+
+
+    printf("%sREGION: %p, size %u storage is %s, ",
+           prefix,
+           rgn,
+           rgn->rects_size,
+           (rgn->rects == rgn->buf) ? "BUF" : "MALLOC");
+
+    if (rgn->num_rects == 0) {
+        printf("EMPTY\n");
+        return;
+    }
+
+    printf("num %u bounds (%d, %d, %d, %d)\n",
+           rgn->num_rects,
+           rgn->bbox.top,
+           rgn->bbox.left,
+           rgn->bbox.bottom,
+           rgn->bbox.right);
+
+    for (i = 0; i < rgn->num_rects; i++) {
+        printf("%s  %12d %12d %12d %12d\n",
+               indent,
+               rgn->rects[i].top,
+               rgn->rects[i].left,
+               rgn->rects[i].bottom,
+               rgn->rects[i].right);
+    }
+    free(indent);
+    ASSERT(region_is_valid(rgn));
+}
+
+int region_is_empty(const QRegion *rgn)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    return !rgn->num_rects;
+}
+
+#ifdef REGION_USE_IMPROVED
+
+int region_is_equal(const QRegion *rgn1, const QRegion *rgn2)
+{
+    int test_res;
+
+    ASSERT(REGION_IS_VALID(rgn1));
+    ASSERT(REGION_IS_VALID(rgn2));
+
+    if (rgn1->num_rects == 0 || rgn2->num_rects == 0) {
+        return rgn1->num_rects == rgn2->num_rects;
+    }
+
+    if (!rect_is_equal(&rgn1->bbox, &rgn2->bbox)) {
+        return FALSE;
+    }
+
+    test_res = region_test(rgn1, rgn2, REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_RIGHT_EXCLUSIVE);
+    return !test_res;
+}
+
+#else
+
+int region_is_equal(const QRegion *rgn1, const QRegion *rgn2)
+{
+    QRegion tmp_rgn;
+    int ret;
+
+    ASSERT(REGION_IS_VALID(rgn1));
+    ASSERT(REGION_IS_VALID(rgn2));
+
+    if (rgn1->num_rects == 0 || rgn2->num_rects == 0) {
+        return rgn1->num_rects == rgn2->num_rects;
+    }
+
+    if (!rect_is_equal(&rgn1->bbox, &rgn2->bbox)) {
+        return FALSE;
+    }
+
+    region_clone(&tmp_rgn, rgn1);
+    region_xor(&tmp_rgn, rgn2);
+    ret = region_is_empty(&tmp_rgn);
+    region_destroy(&tmp_rgn);
+    return ret;
+}
+
+#endif
+
+typedef struct RgnOpCtx {
+    Rect *now;
+    Rect *end;
+    Rect *scan_line;
+    Rect r;
+    Rect split;
+#ifdef REGION_USE_IMPROVED
+    int abort;
+#endif
+} RgnOpCtx;
+
+static inline int op_ctx_is_valid(RgnOpCtx *ctx)
+{
+    return ctx->now != ctx->end;
+}
+
+static void op_context_next(RgnOpCtx *ctx)
+{
+    Rect *now;
+    Rect *next;
+
+    ASSERT(op_ctx_is_valid(ctx));
+    now = ctx->now;
+    next = now + 1;
+
+    if (next == ctx->end || now->top != next->top) {
+        if (now->bottom != ctx->r.bottom) { //h_split
+            ctx->r.top = ctx->r.bottom;
+            ctx->r.bottom = now->bottom;
+            next = ctx->scan_line;
+        } else {
+            if (next == ctx->end) {
+#ifdef REGION_USE_IMPROVED
+                ctx->scan_line = ++ctx->now;
+#else
+                ++ctx->now;
+#endif
+                ctx->r.top = ctx->r.left = ctx->r.bottom = ctx->r.right = (1U << 31) - 1;
+                return;
+            }
+            ctx->scan_line = next;
+            ctx->r.top = next->top;
+            ctx->r.bottom = next->bottom;
+        }
+    }
+    ctx->r.left = next->left;
+    ctx->r.right = next->right;
+    ctx->now = next;
+}
+
+static void op_context_init(RgnOpCtx *ctx, uint32_t num_rects, Rect *rects)
+{
+    ctx->scan_line = ctx->now = rects;
+    ctx->end = ctx->now + num_rects;
+#ifdef REGION_USE_IMPROVED
+    ctx->abort = FALSE;
+#endif
+    if (!op_ctx_is_valid(ctx)) {
+        ctx->r.top = ctx->r.left = ctx->r.bottom = ctx->r.right = (1U << 31) - 1;
+    } else {
+        ctx->r = *ctx->now;
+    }
+}
+
+static inline void op_ctx_h_split(RgnOpCtx *ctx, int32_t h_line)
+{
+    ctx->r.bottom = h_line;
+    ctx->split = ctx->r;
+    op_context_next(ctx);
+}
+
+static inline void op_ctx_v_split(RgnOpCtx *ctx, int32_t v_line)
+{
+    ctx->split = ctx->r;
+    ctx->r.left = ctx->split.right = v_line;
+    if (rect_is_empty(&ctx->r)) {
+        op_context_next(ctx);
+    }
+}
+
+static inline void op_ctx_split(RgnOpCtx *ctx, int32_t h_line)
+{
+    ASSERT(ctx->now == ctx->scan_line);
+    ctx->r.bottom = h_line;
+}
+
+static void region_steal_rects(QRegion *rgn, uint32_t *num_rects, Rect **rects)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    if ((*num_rects = rgn->num_rects)) {
+        if (rgn->rects == rgn->buf) {
+            *rects = (Rect *)malloc(sizeof(Rect) * rgn->num_rects);
+            memcpy(*rects, rgn->rects, sizeof(Rect) * rgn->num_rects);
+        } else {
+            *rects = rgn->rects;
+#ifdef ALLOC_ON_STEAL
+            rgn->rects = (Rect *)malloc(sizeof(Rect) * rgn->num_rects);
+            rgn->rects_size = rgn->num_rects;
+            rgn->num_rects = 0;
+            return;
+#endif
+        }
+    } else {
+        *rects = NULL;
+    }
+    __region_init(rgn);
+    ASSERT(REGION_IS_VALID(rgn));
+}
+
+typedef struct JoinContext {
+    QRegion *rgn;
+    Rect *line0;
+    Rect *line1;
+    Rect *end;
+} JoinContext;
+
+static inline Rect *__get_line(QRegion *rgn, Rect *pos)
+{
+    Rect *end = rgn->rects + rgn->num_rects;
+
+    if (pos < end) {
+        int32_t line_top = pos->top;
+        while (++pos < end && pos->top == line_top) {
+            ASSERT((pos - 1)->right < pos->left); //join in region_push_rect
+        }
+    }
+    return pos;
+}
+
+static inline int region_join_init(QRegion *rgn, JoinContext *context)
+{
+    context->rgn = rgn;
+    context->end = __get_line(rgn, (context->line1 = rgn->rects));
+    return context->end != context->line1;
+}
+
+static inline int region_join_next(JoinContext *context)
+{
+    context->line0 = context->line1;
+    context->line1 = context->end;
+    context->end = __get_line(context->rgn, context->line1);
+    return context->end != context->line1;
+}
+
+static inline void region_join_join(JoinContext *context)
+{
+    Rect *pos_0 = context->line0;
+    Rect *pos_1 = context->line1;
+    int32_t bottom;
+    QRegion *rgn;
+
+    if (pos_0->bottom != pos_1->top) {
+        return;
+    }
+
+    if (pos_1 - pos_0 != context->end - pos_1) {
+        return;
+    }
+
+    for (; pos_1 < context->end; pos_0++, pos_1++) {
+        if (pos_0->left != pos_1->left || pos_0->right != pos_1->right) {
+            return;
+        }
+    }
+    bottom = context->line1->bottom;
+    pos_0 = context->line0;
+    for (; pos_0 < context->line1; pos_0++) {
+        pos_0->bottom = bottom;
+    }
+    rgn = context->rgn;
+    memmove(context->line1, context->end,
+            (unsigned long)(rgn->rects + rgn->num_rects) - (unsigned long)context->end);
+    rgn->num_rects -= (context->line1 - context->line0);
+    context->end = context->line1;
+    context->line1 = context->line0;
+}
+
+static inline void region_join(QRegion *rgn)
+{
+    JoinContext context;
+
+    ASSERT(REGION_IS_VALID(rgn));
+
+    if (!region_join_init(rgn, &context)) {
+        return;
+    }
+    while (region_join_next(&context)) {
+        region_join_join(&context);
+    }
+
+    ASSERT(REGION_IS_VALID(rgn));
+}
+
+static void region_push_rect(QRegion *rgn, Rect *r)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(rect_is_valid(r));
+    if (rgn->num_rects == 0) {
+        rgn->num_rects++;
+        rgn->rects[0] = rgn->bbox = *r;
+        return;
+    } else {
+        Rect *priv = &rgn->rects[rgn->num_rects - 1];
+
+        if (priv->top == r->top && priv->right == r->left) {
+            ASSERT(priv->bottom == r->bottom);
+            priv->right = r->right;
+            rgn->bbox.right = MAX(rgn->bbox.right, priv->right);
+            return;
+        }
+        if (rgn->rects_size == rgn->num_rects) {
+            Rect *old = rgn->rects;
+            rgn->rects_size = rgn->rects_size * 2;
+            rgn->rects = (Rect *)malloc(sizeof(Rect) * rgn->rects_size);
+            memcpy(rgn->rects, old, sizeof(Rect) * rgn->num_rects);
+            if (old != rgn->buf) {
+                free(old);
+            }
+        }
+        rgn->rects[rgn->num_rects++] = *r;
+        rect_union(&rgn->bbox, r);
+    }
+}
+
+#ifdef REGION_USE_IMPROVED
+
+static Rect *op_context_find_area_below(RgnOpCtx *ctx, int32_t val)
+{
+    Rect *start = ctx->now;
+    Rect *end = ctx->end;
+
+    while (start != end) {
+        int pos = (end - start) / 2;
+        if (start[pos].bottom <= val) {
+            start = &start[pos + 1];
+        } else {
+            end = &start[pos];
+        }
+    }
+    return start;
+}
+
+static int op_context_skip_v(RgnOpCtx *ctx, int32_t top)
+{
+    Rect *end = op_context_find_area_below(ctx, top);
+    if (end != ctx->now) {
+        ctx->now = ctx->scan_line = end;
+        if (ctx->now == ctx->end) {
+            ctx->r.top = ctx->r.left = ctx->r.bottom = ctx->r.right = (1U << 31) - 1;
+        } else {
+            ctx->r = *ctx->now;
+        }
+        return TRUE;
+    }
+    return FALSE;
+}
+
+typedef void (*op_callback_t)(RgnOpCtx *context, Rect *, Rect *);
+
+static void op_context_skip(RgnOpCtx *self, RgnOpCtx *other, op_callback_t on_self,
+                            op_callback_t on_other)
+{
+    Rect *save1 = self->now;
+    Rect *save2 = other->now;
+    int more;
+    do {
+        op_context_skip_v(self, other->r.top);
+        if (save1 != self->now) {
+            if (on_self) {
+                on_self(self, save1, self->now);
+            }
+            save1 = self->now;
+        }
+        more = op_context_skip_v(other, self->r.top);
+        if (save2 != other->now) {
+            if (on_other) {
+                on_other(self, save2, other->now);
+            }
+            save2 = other->now;
+        }
+    } while (more && !self->abort);
+}
+
+static inline int op_context_more_overlap(RgnOpCtx *ctx, int32_t *bottom)
+{
+    if (!op_ctx_is_valid(ctx)) {
+        return FALSE;
+    }
+
+    if (ctx->scan_line->bottom > *bottom && ctx->scan_line->top < *bottom) {
+        *bottom = ctx->scan_line->bottom;
+    }
+    return ctx->scan_line->top < *bottom;
+}
+
+static inline void op_context_overlap(RgnOpCtx *self, RgnOpCtx *other, op_callback_t on_self,
+                                      op_callback_t on_other, op_callback_t on_both)
+{
+    int32_t bottom = MAX(self->scan_line->bottom, other->scan_line->bottom);
+
+    do {
+        if (self->r.top < other->r.top) {
+            op_ctx_h_split(self, MIN(other->r.top, self->r.bottom));
+            if (on_self) {
+                on_self(self, &self->split, &self->split + 1);
+            }
+        } else if (self->r.top > other->r.top) {
+            op_ctx_h_split(other, MIN(self->r.top, other->r.bottom));
+            if (on_other) {
+                on_other(self, &other->split, &other->split + 1);
+            }
+        } else {
+            if (self->r.bottom > other->r.bottom) {
+                op_ctx_split(self, other->r.bottom);
+            } else if (other->r.bottom > self->r.bottom) {
+                op_ctx_split(other, self->r.bottom);
+            }
+            if (self->r.left < other->r.left) {
+                op_ctx_v_split(self, MIN(other->r.left, self->r.right));
+                if (on_self) {
+                    on_self(self, &self->split, &self->split + 1);
+                }
+            } else if (self->r.left > other->r.left) {
+                op_ctx_v_split(other, MIN(self->r.left, other->r.right));
+                if (on_other) {
+                    on_other(self, &other->split, &other->split + 1);
+                }
+            } else {
+                int32_t right = MIN(self->r.right, other->r.right);
+                op_ctx_v_split(self, right);
+                op_ctx_v_split(other, right);
+                if (on_both) {
+                    on_both(self, &self->split, &self->split + 1);
+                }
+            }
+        }
+    } while (!self->abort && (op_context_more_overlap(self, &bottom) ||
+                              op_context_more_overlap(other, &bottom)));
+}
+
+static inline void op_context_op(RgnOpCtx *self, RgnOpCtx *other, op_callback_t on_self,
+                                 op_callback_t on_other, op_callback_t on_both)
+{
+    for (;;) {
+        op_context_skip(self, other, on_self, on_other);
+        if (self->abort || !op_ctx_is_valid(self)) {
+            ASSERT(self->abort || !op_ctx_is_valid(other));
+            return;
+        }
+        op_context_overlap(self, other, on_self, on_other, on_both);
+    }
+}
+
+typedef struct SelfOpCtx {
+    RgnOpCtx ctx;
+    QRegion *rgn;
+} SelfOpCtx;
+
+static void add_rects(RgnOpCtx *ctx, Rect *now, Rect *end)
+{
+    SelfOpCtx *self_ctx = (SelfOpCtx *)ctx;
+    for (; now < end; now++) {
+        region_push_rect(self_ctx->rgn, now);
+    }
+}
+
+static void region_op(QRegion *rgn, const QRegion *other_rgn, op_callback_t on_self,
+                      op_callback_t on_other, op_callback_t on_both)
+{
+    SelfOpCtx self;
+    RgnOpCtx other;
+    uint32_t num_rects;
+    Rect *rects;
+
+    region_steal_rects(rgn, &num_rects, &rects);
+    op_context_init(&self.ctx, num_rects, rects);
+    self.rgn = rgn;
+    op_context_init(&other, other_rgn->num_rects, other_rgn->rects);
+    op_context_op(&self.ctx, &other, on_self, on_other, on_both);
+    free(rects);
+    region_join(rgn);
+}
+
+void region_or(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, add_rects, add_rects, add_rects);
+}
+
+void region_and(QRegion *rgn, const QRegion *other_rgn)
+{
+    if (!region_bounds_intersects(rgn, other_rgn)) {
+        region_clear(rgn);
+        return;
+    }
+    region_op(rgn, other_rgn, NULL, NULL, add_rects);
+}
+
+void region_xor(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, add_rects, add_rects, NULL);
+}
+
+void region_exclude(QRegion *rgn, const QRegion *other_rgn)
+{
+    if (!region_bounds_intersects(rgn, other_rgn)) {
+        return;
+    }
+    region_op(rgn, other_rgn, add_rects, NULL, NULL);
+}
+
+typedef struct TestOpCtx {
+    RgnOpCtx ctx;
+    int result;
+    int abort_on;
+} TestOpCtx;
+
+
+static void region_test_on_self(RgnOpCtx *ctx, Rect *now, Rect *end)
+{
+    TestOpCtx *test_ctx = (TestOpCtx *)ctx;
+    test_ctx->result |= REGION_TEST_LEFT_EXCLUSIVE;
+    test_ctx->result &= test_ctx->abort_on;
+    if (test_ctx->result == test_ctx->abort_on) {
+        test_ctx->ctx.abort = TRUE;
+    }
+}
+
+static void region_test_on_other(RgnOpCtx *ctx, Rect *now, Rect *end)
+{
+    TestOpCtx *test_ctx = (TestOpCtx *)ctx;
+    test_ctx->result |= REGION_TEST_RIGHT_EXCLUSIVE;
+    test_ctx->result &= test_ctx->abort_on;
+    if (test_ctx->result == test_ctx->abort_on) {
+        test_ctx->ctx.abort = TRUE;
+    }
+}
+
+static void region_test_on_both(RgnOpCtx *ctx, Rect *now, Rect *end)
+{
+    TestOpCtx *test_ctx = (TestOpCtx *)ctx;
+    test_ctx->result |= REGION_TEST_SHARED;
+    test_ctx->result &= test_ctx->abort_on;
+    if (test_ctx->result == test_ctx->abort_on) {
+        test_ctx->ctx.abort = TRUE;
+    }
+}
+
+int region_test(const QRegion *rgn, const QRegion *other_rgn, int query)
+{
+    TestOpCtx self;
+    RgnOpCtx other;
+
+    op_context_init(&self.ctx, rgn->num_rects, rgn->rects);
+    self.result = 0;
+    self.abort_on = (query) ? query & REGION_TEST_ALL : REGION_TEST_ALL;
+    op_context_init(&other, other_rgn->num_rects, other_rgn->rects);
+    op_context_op(&self.ctx, &other, region_test_on_self, region_test_on_other,
+                  region_test_on_both);
+    return self.result;
+}
+
+#else
+
+#define RIGION_OP_ADD_SELF (1 << 0)
+#define RIGION_OP_ADD_OTHER (1 << 1)
+#define RIGION_OP_ADD_COMMON (1 << 2)
+
+static inline void region_on_self(QRegion *rgn, Rect *r, uint32_t op)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    if (op & RIGION_OP_ADD_SELF) {
+        region_push_rect(rgn, r);
+    }
+}
+
+static inline void region_on_other(QRegion *rgn, Rect *r, uint32_t op)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    if (op & RIGION_OP_ADD_OTHER) {
+        region_push_rect(rgn, r);
+    }
+}
+
+static inline void region_on_both(QRegion *rgn, Rect *r, uint32_t op)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    if (op & RIGION_OP_ADD_COMMON) {
+        region_push_rect(rgn, r);
+    }
+}
+
+static void region_op(QRegion *rgn, const QRegion *other_rgn, uint32_t op)
+{
+    RgnOpCtx self;
+    RgnOpCtx other;
+    uint32_t num_rects;
+    Rect *rects;
+
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(REGION_IS_VALID(other_rgn));
+    region_steal_rects(rgn, &num_rects, &rects);
+
+    op_context_init(&self, num_rects, rects);
+    op_context_init(&other, other_rgn->num_rects, other_rgn->rects);
+
+    while (op_ctx_is_valid(&self) || op_ctx_is_valid(&other)) {
+        if (self.r.top < other.r.top) {
+            op_ctx_h_split(&self, MIN(other.r.top, self.r.bottom));
+            region_on_self(rgn, &self.split, op);
+        } else if (self.r.top > other.r.top) {
+            op_ctx_h_split(&other, MIN(self.r.top, other.r.bottom));
+            region_on_other(rgn, &other.split, op);
+        } else {
+            if (self.r.bottom > other.r.bottom) {
+                op_ctx_split(&self, other.r.bottom);
+            } else if (other.r.bottom > self.r.bottom) {
+                op_ctx_split(&other, self.r.bottom);
+            }
+            if (self.r.left < other.r.left) {
+                op_ctx_v_split(&self, MIN(other.r.left, self.r.right));
+                region_on_self(rgn, &self.split, op);
+            } else if (self.r.left > other.r.left) {
+                op_ctx_v_split(&other, MIN(self.r.left, other.r.right));
+                region_on_other(rgn, &other.split, op);
+            } else {
+                int32_t right = MIN(self.r.right, other.r.right);
+                op_ctx_v_split(&self, right);
+                op_ctx_v_split(&other, right);
+                region_on_both(rgn, &self.split, op);
+            }
+        }
+    }
+    free(rects);
+    region_join(rgn);
+}
+
+void region_or(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, RIGION_OP_ADD_SELF | RIGION_OP_ADD_OTHER | RIGION_OP_ADD_COMMON);
+}
+
+void region_and(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, RIGION_OP_ADD_COMMON);
+}
+
+void region_xor(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, RIGION_OP_ADD_SELF | RIGION_OP_ADD_OTHER);
+}
+
+void region_exclude(QRegion *rgn, const QRegion *other_rgn)
+{
+    region_op(rgn, other_rgn, RIGION_OP_ADD_SELF);
+}
+
+#endif
+
+
+void region_offset(QRegion *rgn, int32_t dx, int32_t dy)
+{
+    Rect *now;
+    Rect *end;
+    ASSERT(REGION_IS_VALID(rgn));
+    if (region_is_empty(rgn)) {
+        return;
+    }
+    rect_offset(&rgn->bbox, dx, dy);
+    now = rgn->rects;
+    end = now + rgn->num_rects;
+    for (; now < end; now++) {
+        rect_offset(now, dx, dy);
+    }
+}
+
+void region_add(QRegion *rgn, const Rect *r)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(rect_is_valid(r));
+
+    if (!rgn->num_rects) {
+        if (rect_is_empty(r)) {
+            return;
+        }
+        rgn->num_rects++;
+        rgn->rects[0] = rgn->bbox = *r;
+    } else {
+        QRegion rect_rgn;
+        region_init(&rect_rgn);
+        region_add(&rect_rgn, r);
+        region_or(rgn, &rect_rgn);
+    }
+}
+
+void region_remove(QRegion *rgn, const Rect *r)
+{
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(rect_is_valid(r));
+    if (rgn->num_rects) {
+        QRegion rect_rgn;
+
+        region_init(&rect_rgn);
+        region_add(&rect_rgn, r);
+        region_exclude(rgn, &rect_rgn);
+    }
+}
+
+#ifdef REGION_USE_IMPROVED
+
+int region_intersects(const QRegion *rgn1, const QRegion *rgn2)
+{
+    int test_res;
+
+    ASSERT(REGION_IS_VALID(rgn1));
+    ASSERT(REGION_IS_VALID(rgn2));
+
+    if (!region_bounds_intersects(rgn1, rgn2)) {
+        return FALSE;
+    }
+
+    test_res = region_test(rgn1, rgn2, REGION_TEST_SHARED);
+    return !!test_res;
+}
+
+#else
+
+int region_intersects(const QRegion *rgn1, const QRegion *rgn2)
+{
+    QRegion tmp;
+    int ret;
+
+    ASSERT(REGION_IS_VALID(rgn1));
+    ASSERT(REGION_IS_VALID(rgn2));
+
+    region_clone(&tmp, rgn1);
+    region_and(&tmp, rgn2);
+    ret = !region_is_empty(&tmp);
+    region_destroy(&tmp);
+    return ret;
+}
+
+#endif
+
+int region_bounds_intersects(const QRegion *rgn1, const QRegion *rgn2)
+{
+    return !region_is_empty(rgn1) && !region_is_empty(rgn2) &&
+           rect_intersects(&rgn1->bbox, &rgn2->bbox);
+}
+
+#ifdef REGION_USE_IMPROVED
+
+int region_contains(const QRegion *rgn, const QRegion *other)
+{
+    int test_res;
+
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(REGION_IS_VALID(other));
+
+    test_res = region_test(rgn, other, REGION_TEST_RIGHT_EXCLUSIVE);
+    return !test_res;
+}
+
+#else
+
+int region_contains(const QRegion *rgn, const QRegion *other)
+{
+    QRegion tmp;
+    int ret;
+
+    ASSERT(REGION_IS_VALID(rgn));
+    ASSERT(REGION_IS_VALID(other));
+
+    region_clone(&tmp, rgn);
+    region_and(&tmp, other);
+    ret = region_is_equal(&tmp, other);
+    region_destroy(&tmp);
+    return ret;
+}
+
+#endif
+
+int region_contains_point(const QRegion *rgn, int32_t x, int32_t y)
+{
+    if (region_is_empty(rgn)) {
+        return FALSE;
+    }
+    Rect point;
+    point.left = x;
+    point.right = point.left + 1;
+    point.top = y;
+    point.bottom = point.top + 1;
+
+    if (!rect_intersects(&rgn->bbox, &point)) {
+        return FALSE;
+    }
+
+    Rect* now = rgn->rects;
+    Rect* end = now + rgn->num_rects;
+
+    for (; now < end; now++) {
+        if (rect_intersects(now, &point)) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+#ifdef REGION_TEST
+
+static void test(const QRegion *r1, const QRegion *r2, int *expected)
+{
+    printf("r1 is_empty %s [%s]\n",
+           region_is_empty(r1) ? "TRUE" : "FALSE",
+           (region_is_empty(r1) == *(expected++)) ? "OK" : "ERR");
+    printf("r2 is_empty %s [%s]\n",
+           region_is_empty(r2) ? "TRUE" : "FALSE",
+           (region_is_empty(r2) == *(expected++)) ? "OK" : "ERR");
+    printf("is_equal %s [%s]\n",
+           region_is_equal(r1, r2) ? "TRUE" : "FALSE",
+           (region_is_equal(r1, r2) == *(expected++)) ? "OK" : "ERR");
+    printf("intersects %s [%s]\n",
+           region_intersects(r1, r2) ? "TRUE" : "FALSE",
+           (region_intersects(r1, r2) == *(expected++)) ? "OK" : "ERR");
+    printf("contains %s [%s]\n",
+           region_contains(r1, r2) ? "TRUE" : "FALSE",
+           (region_contains(r1, r2) == *(expected++)) ? "OK" : "ERR");
+}
+
+enum {
+    EXPECT_R1_EMPTY,
+    EXPECT_R2_EMPTY,
+    EXPECT_EQUAL,
+    EXPECT_SECT,
+    EXPECT_CONT,
+};
+
+int main(void)
+{
+    QRegion _r1, _r2, _r3;
+    QRegion *r1 = &_r1;
+    QRegion *r2 = &_r2;
+    QRegion *r3 = &_r3;
+    Rect _r;
+    Rect *r = &_r;
+    int expected[5];
+
+    region_init(r1);
+    region_init(r2);
+
+    printf("dump r1 empty rgn [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = TRUE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = TRUE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clone(r3, r1);
+    printf("dump r3 clone rgn [%s]\n", region_is_valid(r3) ? "VALID" : "INVALID");
+    region_dump(r3, "");
+    expected[EXPECT_R1_EMPTY] = TRUE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = TRUE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r3, expected);
+    region_destroy(r3);
+    printf("\n");
+
+    rect_set(r, 0, 0, 100, 100);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r1);
+    rect_set(r, 0, 0, 0, 0);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = TRUE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = TRUE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    rect_set(r, -100, -100, 0, 0);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r1);
+    rect_set(r, -100, -100, 100, 100);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+
+    region_clear(r1);
+    region_clear(r2);
+
+    rect_set(r, 100, 100, 200, 200);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    rect_set(r, 300, 300, 400, 400);
+    region_add(r1, r);
+    printf("dump r1 [%s]\n", region_is_valid(r1) ? "VALID" : "INVALID");
+    region_dump(r1, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = TRUE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    rect_set(r, 500, 500, 600, 600);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = FALSE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, 100, 100, 200, 200);
+    region_add(r2, r);
+    rect_set(r, 300, 300, 400, 400);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = TRUE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, 100, 100, 200, 200);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, -2000, -2000, -1000, -1000);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = FALSE;
+    expected[EXPECT_CONT] = FALSE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, -2000, -2000, 1000, 1000);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = FALSE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, 150, 150, 175, 175);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_clear(r2);
+
+    rect_set(r, 150, 150, 350, 350);
+    region_add(r2, r);
+    printf("dump r2 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = FALSE;
+    test(r1, r2, expected);
+    printf("\n");
+
+    region_and(r2, r1);
+    printf("dump r2 and r1 [%s]\n", region_is_valid(r2) ? "VALID" : "INVALID");
+    region_dump(r2, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = FALSE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = FALSE;
+    test(r2, r1, expected);
+    printf("\n");
+
+
+    region_clone(r3, r1);
+    printf("dump r3 clone rgn [%s]\n", region_is_valid(r3) ? "VALID" : "INVALID");
+    region_dump(r3, "");
+    expected[EXPECT_R1_EMPTY] = FALSE;
+    expected[EXPECT_R2_EMPTY] = FALSE;
+    expected[EXPECT_EQUAL] = TRUE;
+    expected[EXPECT_SECT] = TRUE;
+    expected[EXPECT_CONT] = TRUE;
+    test(r1, r3, expected);
+    printf("\n");
+
+
+    region_destroy(r3);
+    region_destroy(r1);
+    region_destroy(r2);
+
+    return 0;
+}
+
+#endif
+
diff --git a/common/region.h b/common/region.h
new file mode 100644
index 00000000..29a58223
--- /dev/null
+++ b/common/region.h
@@ -0,0 +1,75 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REGION
+#define _H_REGION
+
+#include <stdint.h>
+#include "draw.h"
+
+#define REGION_USE_IMPROVED
+
+#define RECTS_BUF_SIZE 4
+
+typedef struct QRegion {
+    uint32_t num_rects;
+    Rect bbox;
+    Rect *rects;
+    uint32_t rects_size;
+    Rect buf[RECTS_BUF_SIZE];
+} QRegion;
+
+#ifdef REGION_USE_IMPROVED
+
+#define REGION_TEST_LEFT_EXCLUSIVE (1 << 0)
+#define REGION_TEST_RIGHT_EXCLUSIVE (1 << 1)
+#define REGION_TEST_SHARED (1 << 2)
+#define REGION_TEST_ALL \
+    (REGION_TEST_LEFT_EXCLUSIVE | REGION_TEST_RIGHT_EXCLUSIVE | REGION_TEST_SHARED)
+
+#endif
+
+void region_init(QRegion *rgn);
+void region_clear(QRegion *rgn);
+void region_destroy(QRegion *rgn);
+void region_clone(QRegion *dest, const QRegion *src);
+
+#ifdef REGION_USE_IMPROVED
+int region_test(const QRegion *rgn, const QRegion *other_rgn, int query);
+#endif
+int region_is_valid(const QRegion *rgn);
+int region_is_empty(const QRegion *rgn);
+int region_is_equal(const QRegion *rgn1, const QRegion *rgn2);
+int region_intersects(const QRegion *rgn1, const QRegion *rgn2);
+int region_bounds_intersects(const QRegion *rgn1, const QRegion *rgn2);
+int region_contains(const QRegion *rgn, const QRegion *other);
+int region_contains_point(const QRegion *rgn, int32_t x, int32_t y);
+
+void region_or(QRegion *rgn, const QRegion *other_rgn);
+void region_and(QRegion *rgn, const QRegion *other_rgn);
+void region_xor(QRegion *rgn, const QRegion *other_rgn);
+void region_exclude(QRegion *rgn, const QRegion *other_rgn);
+
+void region_add(QRegion *rgn, const Rect *r);
+void region_remove(QRegion *rgn, const Rect *r);
+
+void region_offset(QRegion *rgn, int32_t dx, int32_t dy);
+
+void region_dump(const QRegion *rgn, const char *prefix);
+
+#endif
+
diff --git a/common/ring.h b/common/ring.h
new file mode 100644
index 00000000..4c177132
--- /dev/null
+++ b/common/ring.h
@@ -0,0 +1,132 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RING2
+#define _H_RING2
+
+typedef struct Ring RingItem;
+typedef struct Ring {
+    RingItem *prev;
+    RingItem *next;
+} Ring;
+
+static inline void ring_init(Ring *ring)
+{
+    ring->next = ring->prev = ring;
+}
+
+static inline void ring_item_init(RingItem *item)
+{
+    item->next = item->prev = NULL;
+}
+
+static inline int ring_item_is_linked(RingItem *item)
+{
+    return !!item->next;
+}
+
+static inline int ring_is_empty(Ring *ring)
+{
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+    return ring == ring->next;
+}
+
+static inline void ring_add(Ring *ring, RingItem *item)
+{
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+    ASSERT(item->next == NULL && item->prev == NULL);
+
+    item->next = ring->next;
+    item->prev = ring;
+    ring->next = item->next->prev = item;
+}
+
+static inline void ring_add_after(RingItem *item, RingItem *pos)
+{
+    ring_add(pos, item);
+}
+
+static inline void ring_add_before(RingItem *item, RingItem *pos)
+{
+    ring_add(pos->prev, item);
+}
+
+static inline void __ring_remove(RingItem *item)
+{
+    item->next->prev = item->prev;
+    item->prev->next = item->next;
+    item->prev = item->next = 0;
+}
+
+static inline void ring_remove(RingItem *item)
+{
+    ASSERT(item->next != NULL && item->prev != NULL);
+    ASSERT(item->next != item);
+
+    __ring_remove(item);
+}
+
+static inline RingItem *ring_get_head(Ring *ring)
+{
+    RingItem *ret;
+
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+
+    if (ring_is_empty(ring)) {
+        return NULL;
+    }
+    ret = ring->next;
+    return ret;
+}
+
+static inline RingItem *ring_get_tail(Ring *ring)
+{
+    RingItem *ret;
+
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+
+    if (ring_is_empty(ring)) {
+        return NULL;
+    }
+    ret = ring->prev;
+    return ret;
+}
+
+static inline RingItem *ring_next(Ring *ring, RingItem *pos)
+{
+    RingItem *ret;
+
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+    ASSERT(pos);
+    ASSERT(pos->next != NULL && pos->prev != NULL);
+    ret = pos->next;
+    return (ret == ring) ? NULL : ret;
+}
+
+static inline RingItem *ring_prev(Ring *ring, RingItem *pos)
+{
+    RingItem *ret;
+
+    ASSERT(ring->next != NULL && ring->prev != NULL);
+    ASSERT(pos);
+    ASSERT(pos->next != NULL && pos->prev != NULL);
+    ret = pos->prev;
+    return (ret == ring) ? NULL : ret;
+}
+
+#endif
+
diff --git a/common/rop3.c b/common/rop3.c
new file mode 100644
index 00000000..08f9cad3
--- /dev/null
+++ b/common/rop3.c
@@ -0,0 +1,613 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+
+#include "rop3.h"
+
+#ifndef WARN
+#define WARN(x) printf("warning: %s\n", x)
+#endif
+
+typedef void (*rop3_with_pattern_handler_t)(cairo_surface_t *d, cairo_surface_t *s,
+                                            Point *src_pos, cairo_surface_t *p,
+                                            Point *pat_pos);
+
+typedef void (*rop3_with_color_handler_t)(cairo_surface_t *d, cairo_surface_t *s,
+                                          Point *src_pos, uint32_t rgb);
+
+typedef void (*rop3_test_handler_t)();
+
+#define ROP3_NUM_OPS 256
+
+static rop3_with_pattern_handler_t rop3_with_pattern_handlers[ROP3_NUM_OPS];
+static rop3_with_color_handler_t rop3_with_color_handlers[ROP3_NUM_OPS];
+static rop3_test_handler_t rop3_test_handlers[ROP3_NUM_OPS];
+
+
+static void default_rop3_with_pattern_handler(cairo_surface_t *d, cairo_surface_t *s,
+                                              Point *src_pos, cairo_surface_t *p,
+                                              Point *pat_pos)
+{
+    WARN("not implemented 0x%x");
+}
+
+static void default_rop3_withe_color_handler(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+                                             uint32_t rgb)
+{
+    WARN("not implemented 0x%x");
+}
+
+static void default_rop3_test_handler()
+{
+}
+
+#define ROP3_HANDLERS(name, formula, index)                                                     \
+static void rop3_handle_p_##name(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,        \
+                                      cairo_surface_t *p, Point *pat_pos)                       \
+{                                                                                               \
+    int width = cairo_image_surface_get_width(d);                                               \
+    int height = cairo_image_surface_get_height(d);                                             \
+    uint8_t *dest_line = cairo_image_surface_get_data(d);                                       \
+    int dest_stride = cairo_image_surface_get_stride(d);                                        \
+    uint8_t *end_line = dest_line + height * dest_stride;                                       \
+                                                                                                \
+    int pat_width = cairo_image_surface_get_width(p);                                           \
+    int pat_height = cairo_image_surface_get_height(p);                                         \
+    uint8_t *pat_base = cairo_image_surface_get_data(p);                                        \
+    int pat_stride = cairo_image_surface_get_stride(p);                                         \
+    int pat_v_offset = pat_pos->y;                                                              \
+                                                                                                \
+    int src_stride = cairo_image_surface_get_stride(s);                                         \
+    uint8_t *src_line;                                                                          \
+    src_line = cairo_image_surface_get_data(s) + src_pos->y * src_stride + (src_pos->x << 2);   \
+                                                                                                \
+    for (; dest_line < end_line; dest_line += dest_stride, src_line += src_stride) {            \
+        uint32_t *dest = (uint32_t *)dest_line;                                                 \
+        uint32_t *end = dest + width;                                                           \
+        uint32_t *src = (uint32_t *)src_line;                                                   \
+                                                                                                \
+        int pat_h_offset = pat_pos->x;                                                          \
+                                                                                                \
+        for (; dest < end; dest++, src++) {                                                     \
+            uint32_t *pat;                                                                      \
+            pat  = (uint32_t *)(pat_base + pat_v_offset * pat_stride + (pat_h_offset << 2));    \
+            *dest = formula;                                                                    \
+            pat_h_offset = (pat_h_offset + 1) % pat_width;                                      \
+        }                                                                                       \
+                                                                                                \
+        pat_v_offset = (pat_v_offset + 1) % pat_height;                                         \
+    }                                                                                           \
+}                                                                                               \
+                                                                                                \
+static void rop3_handle_c_##name(cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,        \
+                                   uint32_t rgb)                                                \
+{                                                                                               \
+    int width = cairo_image_surface_get_width(d);                                               \
+    int height = cairo_image_surface_get_height(d);                                             \
+    uint8_t *dest_line = cairo_image_surface_get_data(d);                                       \
+    int dest_stride = cairo_image_surface_get_stride(d);                                        \
+    uint8_t *end_line = dest_line + height * dest_stride;                                       \
+    uint32_t *pat = &rgb;                                                                       \
+                                                                                                \
+    int src_stride = cairo_image_surface_get_stride(s);                                         \
+    uint8_t *src_line;                                                                          \
+    src_line = cairo_image_surface_get_data(s) + src_pos->y * src_stride + (src_pos->x << 2);   \
+                                                                                                \
+    for (; dest_line < end_line; dest_line += dest_stride, src_line += src_stride) {            \
+        uint32_t *dest = (uint32_t *)dest_line;                                                 \
+        uint32_t *end = dest + width;                                                           \
+        uint32_t *src = (uint32_t *)src_line;                                                   \
+        for (; dest < end; dest++, src++) {                                                     \
+            *dest = formula;                                                                    \
+        }                                                                                       \
+    }                                                                                           \
+}                                                                                               \
+                                                                                                \
+static void rop3_test_##name()                                                                  \
+{                                                                                               \
+    uint8_t d = 0xaa;                                                                           \
+    uint8_t s = 0xcc;                                                                           \
+    uint8_t p = 0xf0;                                                                           \
+    uint8_t *pat = &p;                                                                          \
+    uint8_t *src = &s;                                                                          \
+    uint8_t *dest = &d;                                                                         \
+                                                                                                \
+    d = formula;                                                                                \
+    if (d != index) {                                                                           \
+        printf("%s: failed, result is 0x%x expect 0x%x\n", __FUNCTION__, d, index);             \
+    }                                                                                           \
+}
+
+ROP3_HANDLERS(DPSoon, ~(*pat | *src | *dest), 0x01);
+ROP3_HANDLERS(DPSona, ~(*pat | *src) & *dest, 0x02);
+ROP3_HANDLERS(SDPona, ~(*pat | *dest) & *src, 0x04);
+ROP3_HANDLERS(PDSxnon, ~(~(*src ^ *dest) | *pat), 0x06);
+ROP3_HANDLERS(PDSaon, ~((*src & *dest) | *pat), 0x07);
+ROP3_HANDLERS(SDPnaa, ~*pat & *dest & *src, 0x08);
+ROP3_HANDLERS(PDSxon, ~((*src ^ *dest) | *pat), 0x09);
+ROP3_HANDLERS(PSDnaon, ~((~*dest & *src) | *pat), 0x0b);
+ROP3_HANDLERS(PDSnaon, ~((~*src & *dest) | *pat), 0x0d);
+ROP3_HANDLERS(PDSonon, ~(~(*src | *dest) | *pat), 0x0e);
+ROP3_HANDLERS(PDSona, ~(*src | *dest) & *pat, 0x10);
+ROP3_HANDLERS(SDPxnon, ~(~(*pat ^ *dest) | *src), 0x12);
+ROP3_HANDLERS(SDPaon, ~((*pat & *dest) | *src), 0x13);
+ROP3_HANDLERS(DPSxnon, ~(~(*pat ^ *src) | *dest), 0x14);
+ROP3_HANDLERS(DPSaon, ~((*pat & *src) | *dest), 0x15);
+ROP3_HANDLERS(PSDPSanaxx, (~(*pat & *src) & *dest) ^ *src ^ *pat, 0x16);
+ROP3_HANDLERS(SSPxDSxaxn, ~(((*src ^ *dest) & (*src ^ *pat)) ^ *src), 0x17);
+ROP3_HANDLERS(SPxPDxa, (*src ^ *pat) & (*pat ^ *dest), 0x18);
+ROP3_HANDLERS(SDPSanaxn, ~((~(*pat & *src) & *dest) ^ *src), 0x19);
+ROP3_HANDLERS(PDSPaox, ((*pat & *src) | *dest) ^ *pat, 0x1a);
+ROP3_HANDLERS(SDPSxaxn, ~(((*pat ^ *src) & *dest) ^ *src), 0x1b);
+ROP3_HANDLERS(PSDPaox, ((*pat & *dest) | *src) ^ *pat, 0x1c);
+ROP3_HANDLERS(DSPDxaxn, ~(((*pat ^ *dest) & *src) ^ *dest), 0x1d);
+ROP3_HANDLERS(PDSox, (*dest | *src) ^ *pat, 0x1e);
+ROP3_HANDLERS(PDSoan, ~((*src | *dest) & *pat), 0x1f);
+ROP3_HANDLERS(DPSnaa, ~*src & *pat & *dest, 0x20);
+ROP3_HANDLERS(SDPxon, ~((*pat ^ *dest) | *src), 0x21);
+ROP3_HANDLERS(SPDnaon, ~((~*dest & *pat) | *src), 0x23);
+ROP3_HANDLERS(SPxDSxa, (*src ^ *pat) & (*dest ^ *src), 0x24);
+ROP3_HANDLERS(PDSPanaxn, ~((~(*src & *pat) & *dest) ^ *pat), 0x25);
+ROP3_HANDLERS(SDPSaox, ((*src & *pat) | *dest) ^ *src, 0x26);
+ROP3_HANDLERS(SDPSxnox, (~(*src ^ *pat) | *dest) ^ *src, 0x27);
+ROP3_HANDLERS(DPSxa, (*pat ^ *src) & *dest, 0x28);
+ROP3_HANDLERS(PSDPSaoxxn, ~(((*src & *pat) | *dest) ^ *src ^ *pat), 0x29);
+ROP3_HANDLERS(DPSana, ~(*src & *pat) & *dest, 0x2a);
+ROP3_HANDLERS(SSPxPDxaxn, ~(((*pat ^ *dest) & (*src ^ *pat)) ^ *src), 0x2b);
+ROP3_HANDLERS(SPDSoax, ((*src | *dest) & *pat) ^ *src, 0x2c);
+ROP3_HANDLERS(PSDnox, (~*dest | *src) ^ *pat, 0x2d);
+ROP3_HANDLERS(PSDPxox, ((*pat ^ *dest) | *src) ^ *pat, 0x2e);
+ROP3_HANDLERS(PSDnoan, ~((~*dest | *src) & *pat), 0x2f);
+ROP3_HANDLERS(SDPnaon, ~((~*pat & *dest) | *src), 0x31);
+ROP3_HANDLERS(SDPSoox, (*src | *pat | *dest) ^ *src, 0x32);
+ROP3_HANDLERS(SPDSaox, ((*src & *dest) | *pat) ^ *src, 0x34);
+ROP3_HANDLERS(SPDSxnox, (~(*src ^ *dest) | *pat) ^ *src, 0x35);
+ROP3_HANDLERS(SDPox, (*pat | *dest) ^ *src, 0x36);
+ROP3_HANDLERS(SDPoan, ~((*pat | *dest) & *src), 0x37);
+ROP3_HANDLERS(PSDPoax, ((*pat | *dest) & *src) ^ *pat, 0x38);
+ROP3_HANDLERS(SPDnox, (~*dest | *pat) ^ *src, 0x39);
+ROP3_HANDLERS(SPDSxox, ((*src ^ *dest) | *pat) ^ *src, 0x3a);
+ROP3_HANDLERS(SPDnoan, ~((~*dest | *pat) & *src), 0x3b);
+ROP3_HANDLERS(SPDSonox, (~(*src | *dest) | *pat) ^ *src, 0x3d);
+ROP3_HANDLERS(SPDSnaox, ((~*src & *dest) | *pat) ^ *src, 0x3e);
+ROP3_HANDLERS(PSDnaa, ~*dest & *src & *pat, 0x40);
+ROP3_HANDLERS(DPSxon, ~((*src ^ *pat) | *dest), 0x41);
+ROP3_HANDLERS(SDxPDxa, (*src ^ *dest) & (*pat ^ *dest), 0x42);
+ROP3_HANDLERS(SPDSanaxn, ~((~(*src & *dest) & *pat) ^ *src), 0x43);
+ROP3_HANDLERS(DPSnaon, ~((~*src & *pat) | *dest), 0x45);
+ROP3_HANDLERS(DSPDaox, ((*dest & *pat) | *src) ^ *dest, 0x46);
+ROP3_HANDLERS(PSDPxaxn, ~(((*pat ^ *dest) & *src) ^ *pat), 0x47);
+ROP3_HANDLERS(SDPxa, (*pat ^ *dest) & *src, 0x48);
+ROP3_HANDLERS(PDSPDaoxxn, ~(((*dest & *pat) | *src) ^ *dest ^ *pat), 0x49);
+ROP3_HANDLERS(DPSDoax, ((*dest | *src) & *pat) ^ *dest, 0x4a);
+ROP3_HANDLERS(PDSnox, (~*src | *dest) ^ *pat, 0x4b);
+ROP3_HANDLERS(SDPana, ~(*pat & *dest) & *src, 0x4c);
+ROP3_HANDLERS(SSPxDSxoxn, ~(((*src ^ *dest) | (*src ^ *pat)) ^ *src), 0x4d);
+ROP3_HANDLERS(PDSPxox, ((*pat ^ *src) | *dest) ^ *pat, 0x4e);
+ROP3_HANDLERS(PDSnoan, ~((~*src | *dest) & *pat), 0x4f);
+ROP3_HANDLERS(DSPnaon, ~((~*pat & *src) | *dest), 0x51);
+ROP3_HANDLERS(DPSDaox, ((*dest & *src) | *pat) ^ *dest, 0x52);
+ROP3_HANDLERS(SPDSxaxn, ~(((*src ^ *dest) & *pat) ^ *src), 0x53);
+ROP3_HANDLERS(DPSonon, ~(~(*src | *pat) | *dest), 0x54);
+ROP3_HANDLERS(DPSox, (*src | *pat) ^ *dest, 0x56);
+ROP3_HANDLERS(DPSoan, ~((*src | *pat) & *dest), 0x57);
+ROP3_HANDLERS(PDSPoax, ((*pat | *src) & *dest) ^ *pat, 0x58);
+ROP3_HANDLERS(DPSnox, (~*src | *pat) ^ *dest, 0x59);
+ROP3_HANDLERS(DPSDonox, (~(*dest | *src) | *pat) ^ *dest, 0x5b);
+ROP3_HANDLERS(DPSDxox, ((*dest ^ *src) | *pat) ^ *dest, 0x5c);
+ROP3_HANDLERS(DPSnoan, ~((~*src | *pat) & *dest), 0x5d);
+ROP3_HANDLERS(DPSDnaox, ((~*dest & *src) | *pat) ^ *dest, 0x5e);
+ROP3_HANDLERS(PDSxa, (*src ^ *dest) & *pat, 0x60);
+ROP3_HANDLERS(DSPDSaoxxn, ~(((*src & *dest) | *pat) ^ *src ^ *dest), 0x61);
+ROP3_HANDLERS(DSPDoax, ((*dest | *pat) & *src) ^ *dest, 0x62);
+ROP3_HANDLERS(SDPnox, (~*pat | *dest) ^ *src, 0x63);
+ROP3_HANDLERS(SDPSoax, ((*src | *pat) & *dest) ^ *src, 0x64);
+ROP3_HANDLERS(DSPnox, (~*pat | *src) ^ *dest, 0x65);
+ROP3_HANDLERS(SDPSonox, (~(*src | *pat) | *dest) ^ *src, 0x67);
+ROP3_HANDLERS(DSPDSonoxxn, ~((~(*src | *dest) | *pat) ^ *src ^ *dest), 0x68);
+ROP3_HANDLERS(PDSxxn, ~(*src ^ *dest ^ *pat), 0x69);
+ROP3_HANDLERS(DPSax, (*src & *pat) ^ *dest, 0x6a);
+ROP3_HANDLERS(PSDPSoaxxn, ~(((*src | *pat) & *dest) ^ *src ^ *pat), 0x6b);
+ROP3_HANDLERS(SDPax, (*pat & *dest) ^ *src, 0x6c);
+ROP3_HANDLERS(PDSPDoaxxn, ~(((*dest | *pat) & *src) ^ *dest ^ *pat), 0x6d);
+ROP3_HANDLERS(SDPSnoax, ((~*src | *pat) & *dest) ^ *src, 0x6e);
+ROP3_HANDLERS(PDSxnan, ~(~(*src ^ *dest) & *pat), 0x6f);
+ROP3_HANDLERS(PDSana, ~(*src & *dest) & *pat, 0x70);
+ROP3_HANDLERS(SSDxPDxaxn, ~(((*dest ^ *pat) & (*src ^ *dest)) ^ *src), 0x71);
+ROP3_HANDLERS(SDPSxox, ((*src ^ *pat) | *dest) ^ *src, 0x72);
+ROP3_HANDLERS(SDPnoan, ~((~*pat | *dest) & *src), 0x73);
+ROP3_HANDLERS(DSPDxox, ((*dest ^ *pat) | *src) ^ *dest, 0x74);
+ROP3_HANDLERS(DSPnoan, ~((~*pat | *src) & *dest), 0x75);
+ROP3_HANDLERS(SDPSnaox, ((~*src & *pat) | *dest) ^ *src, 0x76);
+ROP3_HANDLERS(PDSax, (*src & *dest) ^ *pat, 0x78);
+ROP3_HANDLERS(DSPDSoaxxn, ~(((*src | *dest) & *pat) ^ *src ^ *dest), 0x79);
+ROP3_HANDLERS(DPSDnoax, ((~*dest | *src) & *pat) ^ *dest, 0x7a);
+ROP3_HANDLERS(SDPxnan, ~(~(*pat ^ *dest) & *src), 0x7b);
+ROP3_HANDLERS(SPDSnoax, ((~*src | *dest) & *pat) ^ *src, 0x7c);
+ROP3_HANDLERS(DPSxnan, ~(~(*src ^ *pat) & *dest), 0x7d);
+ROP3_HANDLERS(SPxDSxo, (*src ^ *dest) | (*pat ^ *src), 0x7e);
+ROP3_HANDLERS(DPSaan, ~(*src & *pat & *dest), 0x7f);
+ROP3_HANDLERS(DPSaa, *src & *pat & *dest, 0x80);
+ROP3_HANDLERS(SPxDSxon, ~((*src ^ *dest) | (*pat ^ *src)), 0x81);
+ROP3_HANDLERS(DPSxna, ~(*src ^ *pat) & *dest, 0x82);
+ROP3_HANDLERS(SPDSnoaxn, ~(((~*src | *dest) & *pat) ^ *src), 0x83);
+ROP3_HANDLERS(SDPxna, ~(*pat ^ *dest) & *src, 0x84);
+ROP3_HANDLERS(PDSPnoaxn, ~(((~*pat | *src) & *dest) ^ *pat), 0x85);
+ROP3_HANDLERS(DSPDSoaxx, ((*src | *dest) & *pat) ^ *src ^ *dest, 0x86);
+ROP3_HANDLERS(PDSaxn, ~((*src & *dest) ^ *pat), 0x87);
+ROP3_HANDLERS(SDPSnaoxn, ~(((~*src & *pat) | *dest) ^ *src), 0x89);
+ROP3_HANDLERS(DSPnoa, (~*pat | *src) & *dest, 0x8a);
+ROP3_HANDLERS(DSPDxoxn, ~(((*dest ^ *pat) | *src) ^ *dest), 0x8b);
+ROP3_HANDLERS(SDPnoa, (~*pat | *dest) & *src, 0x8c);
+ROP3_HANDLERS(SDPSxoxn, ~(((*src ^ *pat) | *dest) ^ *src), 0x8d);
+ROP3_HANDLERS(SSDxPDxax, ((*dest ^ *pat) & (*dest ^ *src)) ^ *src, 0x8e);
+ROP3_HANDLERS(PDSanan, ~(~(*src & *dest) & *pat), 0x8f);
+ROP3_HANDLERS(PDSxna, ~(*src ^ *dest) & *pat, 0x90);
+ROP3_HANDLERS(SDPSnoaxn, ~(((~*src | *pat) & *dest) ^ *src), 0x91);
+ROP3_HANDLERS(DPSDPoaxx, ((*pat | *dest) & *src) ^ *pat ^ *dest, 0x92);
+ROP3_HANDLERS(SPDaxn, ~((*dest & *pat) ^ *src), 0x93);
+ROP3_HANDLERS(PSDPSoaxx, ((*src | *pat) & *dest) ^ *src ^ *pat, 0x94);
+ROP3_HANDLERS(DPSaxn, ~((*src & *pat) ^ *dest), 0x95);
+ROP3_HANDLERS(DPSxx, *src ^ *pat ^ *dest, 0x96);
+ROP3_HANDLERS(PSDPSonoxx, (~(*src | *pat) | *dest) ^ *src ^ *pat, 0x97);
+ROP3_HANDLERS(SDPSonoxn, ~((~(*src | *pat) | *dest) ^ *src), 0x98);
+ROP3_HANDLERS(DPSnax, (~*src & *pat) ^ *dest, 0x9a);
+ROP3_HANDLERS(SDPSoaxn, ~(((*src | *pat) & *dest) ^ *src), 0x9b);
+ROP3_HANDLERS(SPDnax, (~*dest & *pat) ^ *src, 0x9c);
+ROP3_HANDLERS(DSPDoaxn, ~(((*dest | *pat) & *src) ^ *dest), 0x9d);
+ROP3_HANDLERS(DSPDSaoxx, ((*src & *dest) | *pat) ^ *src ^ *dest, 0x9e);
+ROP3_HANDLERS(PDSxan, ~((*src ^ *dest) & *pat), 0x9f);
+ROP3_HANDLERS(PDSPnaoxn, ~(((~*pat & *src) | *dest) ^ *pat), 0xa1);
+ROP3_HANDLERS(DPSnoa, (~*src | *pat) & *dest, 0xa2);
+ROP3_HANDLERS(DPSDxoxn, ~(((*dest ^ *src) | *pat) ^ *dest), 0xa3);
+ROP3_HANDLERS(PDSPonoxn, ~((~(*pat | *src) | *dest) ^ *pat), 0xa4);
+ROP3_HANDLERS(DSPnax, (~*pat & *src) ^ *dest, 0xa6);
+ROP3_HANDLERS(PDSPoaxn, ~(((*pat | *src) & *dest) ^ *pat), 0xa7);
+ROP3_HANDLERS(DPSoa, (*src | *pat) & *dest, 0xa8);
+ROP3_HANDLERS(DPSoxn, ~((*src | *pat) ^ *dest), 0xa9);
+ROP3_HANDLERS(DPSono, ~(*src | *pat) | *dest, 0xab);
+ROP3_HANDLERS(SPDSxax, ((*src ^ *dest) & *pat) ^ *src, 0xac);
+ROP3_HANDLERS(DPSDaoxn, ~(((*dest & *src) | *pat) ^ *dest), 0xad);
+ROP3_HANDLERS(DSPnao, (~*pat & *src) | *dest, 0xae);
+ROP3_HANDLERS(PDSnoa, (~*src | *dest) & *pat, 0xb0);
+ROP3_HANDLERS(PDSPxoxn, ~(((*pat ^ *src) | *dest) ^ *pat), 0xb1);
+ROP3_HANDLERS(SSPxDSxox, ((*src ^ *dest) | (*pat ^ *src)) ^ *src, 0xb2);
+ROP3_HANDLERS(SDPanan, ~(~(*pat & *dest) & *src), 0xb3);
+ROP3_HANDLERS(PSDnax, (~*dest & *src) ^ *pat, 0xb4);
+ROP3_HANDLERS(DPSDoaxn, ~(((*dest | *src) & *pat) ^ *dest), 0xb5);
+ROP3_HANDLERS(DPSDPaoxx, ((*pat & *dest) | *src) ^ *pat ^ *dest, 0xb6);
+ROP3_HANDLERS(SDPxan, ~((*pat ^ *dest) & *src), 0xb7);
+ROP3_HANDLERS(PSDPxax, ((*dest ^ *pat) & *src) ^ *pat, 0xb8);
+ROP3_HANDLERS(DSPDaoxn, ~(((*dest & *pat) | *src) ^ *dest), 0xb9);
+ROP3_HANDLERS(DPSnao, (~*src & *pat) | *dest, 0xba);
+ROP3_HANDLERS(SPDSanax, (~(*src & *dest) & *pat) ^ *src, 0xbc);
+ROP3_HANDLERS(SDxPDxan, ~((*dest ^ *pat) & (*dest ^ *src)), 0xbd);
+ROP3_HANDLERS(DPSxo, (*src ^ *pat) | *dest, 0xbe);
+ROP3_HANDLERS(DPSano, ~(*src & *pat) | *dest, 0xbf);
+ROP3_HANDLERS(SPDSnaoxn, ~(((~*src & *dest) | *pat) ^ *src), 0xc1);
+ROP3_HANDLERS(SPDSonoxn, ~((~(*src | *dest) | *pat) ^ *src), 0xc2);
+ROP3_HANDLERS(SPDnoa, (~*dest | *pat) & *src, 0xc4);
+ROP3_HANDLERS(SPDSxoxn, ~(((*src ^ *dest) | *pat) ^ *src), 0xc5);
+ROP3_HANDLERS(SDPnax, (~*pat & *dest) ^ *src, 0xc6);
+ROP3_HANDLERS(PSDPoaxn, ~(((*pat | *dest) & *src) ^ *pat), 0xc7);
+ROP3_HANDLERS(SDPoa, (*pat | *dest) & *src, 0xc8);
+ROP3_HANDLERS(SPDoxn, ~((*dest | *pat) ^ *src), 0xc9);
+ROP3_HANDLERS(DPSDxax, ((*dest ^ *src) & *pat) ^ *dest, 0xca);
+ROP3_HANDLERS(SPDSaoxn, ~(((*src & *dest) | *pat) ^ *src), 0xcb);
+ROP3_HANDLERS(SDPono, ~(*pat | *dest) | *src, 0xcd);
+ROP3_HANDLERS(SDPnao, (~*pat & *dest) | *src, 0xce);
+ROP3_HANDLERS(PSDnoa, (~*dest | *src) & *pat, 0xd0);
+ROP3_HANDLERS(PSDPxoxn, ~(((*pat ^ *dest) | *src) ^ *pat), 0xd1);
+ROP3_HANDLERS(PDSnax, (~*src & *dest) ^ *pat, 0xd2);
+ROP3_HANDLERS(SPDSoaxn, ~(((*src | *dest) & *pat) ^ *src), 0xd3);
+ROP3_HANDLERS(SSPxPDxax, ((*dest ^ *pat) & (*pat ^ *src)) ^ *src, 0xd4);
+ROP3_HANDLERS(DPSanan, ~(~(*src & *pat) & *dest), 0xd5);
+ROP3_HANDLERS(PSDPSaoxx, ((*src & *pat) | *dest) ^ *src ^ *pat, 0xd6);
+ROP3_HANDLERS(DPSxan, ~((*src ^ *pat) & *dest), 0xd7);
+ROP3_HANDLERS(PDSPxax, ((*pat ^ *src) & *dest) ^ *pat, 0xd8);
+ROP3_HANDLERS(SDPSaoxn, ~(((*src & *pat) | *dest) ^ *src), 0xd9);
+ROP3_HANDLERS(DPSDanax, (~(*dest & *src) & *pat) ^ *dest, 0xda);
+ROP3_HANDLERS(SPxDSxan, ~((*src ^ *dest) & (*pat ^ *src)), 0xdb);
+ROP3_HANDLERS(SPDnao, (~*dest & *pat) | *src, 0xdc);
+ROP3_HANDLERS(SDPxo, (*pat ^ *dest) | *src, 0xde);
+ROP3_HANDLERS(SDPano, ~(*pat & *dest) | *src, 0xdf);
+ROP3_HANDLERS(PDSoa, (*src | *dest) & *pat, 0xe0);
+ROP3_HANDLERS(PDSoxn, ~((*src | *dest) ^ *pat), 0xe1);
+ROP3_HANDLERS(DSPDxax, ((*dest ^ *pat) & *src) ^ *dest, 0xe2);
+ROP3_HANDLERS(PSDPaoxn, ~(((*pat & *dest) | *src) ^ *pat), 0xe3);
+ROP3_HANDLERS(SDPSxax, ((*src ^ *pat) & *dest) ^ *src, 0xe4);
+ROP3_HANDLERS(PDSPaoxn, ~(((*pat & *src) | *dest) ^ *pat), 0xe5);
+ROP3_HANDLERS(SDPSanax, (~(*src & *pat) & *dest) ^ *src, 0xe6);
+ROP3_HANDLERS(SPxPDxan, ~((*dest ^ *pat) & (*pat ^ *src)), 0xe7);
+ROP3_HANDLERS(SSPxDSxax, ((*src ^ *dest) & (*pat ^ *src)) ^ *src, 0xe8);
+ROP3_HANDLERS(DSPDSanaxxn, ~((~(*src & *dest) & *pat) ^ *src ^ *dest), 0xe9);
+ROP3_HANDLERS(DPSao, (*src & *pat) | *dest, 0xea);
+ROP3_HANDLERS(DPSxno, ~(*src ^ *pat) | *dest, 0xeb);
+ROP3_HANDLERS(SDPao, (*pat & *dest) | *src, 0xec);
+ROP3_HANDLERS(SDPxno, ~(*pat ^ *dest) | *src, 0xed);
+ROP3_HANDLERS(SDPnoo, ~*pat | *dest | *src, 0xef);
+ROP3_HANDLERS(PDSono, ~(*src | *dest) | *pat, 0xf1);
+ROP3_HANDLERS(PDSnao, (~*src & *dest) | *pat, 0xf2);
+ROP3_HANDLERS(PSDnao, (~*dest & *src) | *pat, 0xf4);
+ROP3_HANDLERS(PDSxo, (*src ^ *dest) | *pat, 0xf6);
+ROP3_HANDLERS(PDSano, ~(*src & *dest) | *pat, 0xf7);
+ROP3_HANDLERS(PDSao, (*src & *dest) | *pat, 0xf8);
+ROP3_HANDLERS(PDSxno, ~(*src ^ *dest) | *pat, 0xf9);
+ROP3_HANDLERS(DPSnoo, ~*src | *pat | *dest, 0xfb);
+ROP3_HANDLERS(PSDnoo, ~*dest | *src | *pat, 0xfd);
+ROP3_HANDLERS(DPSoo, *src | *pat | *dest, 0xfe);
+
+
+
+#define ROP3_FILL_HANDLERS(op, index)                       \
+    rop3_with_pattern_handlers[index] = rop3_handle_p_##op; \
+    rop3_with_color_handlers[index] = rop3_handle_c_##op;   \
+    rop3_test_handlers[index] = rop3_test_##op;
+
+void rop3_init()
+{
+    static int need_init = 1;
+    int i;
+
+    if (!need_init) {
+        return;
+    }
+    need_init = 0;
+
+    for (i = 0; i < ROP3_NUM_OPS; i++) {
+        rop3_with_pattern_handlers[i] = default_rop3_with_pattern_handler;
+        rop3_with_color_handlers[i] = default_rop3_withe_color_handler;
+        rop3_test_handlers[i] = default_rop3_test_handler;
+    }
+
+    ROP3_FILL_HANDLERS(DPSoon, 0x01);
+    ROP3_FILL_HANDLERS(DPSona, 0x02);
+    ROP3_FILL_HANDLERS(SDPona, 0x04);
+    ROP3_FILL_HANDLERS(PDSxnon, 0x06);
+    ROP3_FILL_HANDLERS(PDSaon, 0x07);
+    ROP3_FILL_HANDLERS(SDPnaa, 0x08);
+    ROP3_FILL_HANDLERS(PDSxon, 0x09);
+    ROP3_FILL_HANDLERS(PSDnaon, 0x0b);
+    ROP3_FILL_HANDLERS(PDSnaon, 0x0d);
+    ROP3_FILL_HANDLERS(PDSonon, 0x0e);
+    ROP3_FILL_HANDLERS(PDSona, 0x10);
+    ROP3_FILL_HANDLERS(SDPxnon, 0x12);
+    ROP3_FILL_HANDLERS(SDPaon, 0x13);
+    ROP3_FILL_HANDLERS(DPSxnon, 0x14);
+    ROP3_FILL_HANDLERS(DPSaon, 0x15);
+    ROP3_FILL_HANDLERS(PSDPSanaxx, 0x16);
+    ROP3_FILL_HANDLERS(SSPxDSxaxn, 0x17);
+    ROP3_FILL_HANDLERS(SPxPDxa, 0x18);
+    ROP3_FILL_HANDLERS(SDPSanaxn, 0x19);
+    ROP3_FILL_HANDLERS(PDSPaox, 0x1a);
+    ROP3_FILL_HANDLERS(SDPSxaxn, 0x1b);
+    ROP3_FILL_HANDLERS(PSDPaox, 0x1c);
+    ROP3_FILL_HANDLERS(DSPDxaxn, 0x1d);
+    ROP3_FILL_HANDLERS(PDSox, 0x1e);
+    ROP3_FILL_HANDLERS(PDSoan, 0x1f);
+    ROP3_FILL_HANDLERS(DPSnaa, 0x20);
+    ROP3_FILL_HANDLERS(SDPxon, 0x21);
+    ROP3_FILL_HANDLERS(SPDnaon, 0x23);
+    ROP3_FILL_HANDLERS(SPxDSxa, 0x24);
+    ROP3_FILL_HANDLERS(PDSPanaxn, 0x25);
+    ROP3_FILL_HANDLERS(SDPSaox, 0x26);
+    ROP3_FILL_HANDLERS(SDPSxnox, 0x27);
+    ROP3_FILL_HANDLERS(DPSxa, 0x28);
+    ROP3_FILL_HANDLERS(PSDPSaoxxn, 0x29);
+    ROP3_FILL_HANDLERS(DPSana, 0x2a);
+    ROP3_FILL_HANDLERS(SSPxPDxaxn, 0x2b);
+    ROP3_FILL_HANDLERS(SPDSoax, 0x2c);
+    ROP3_FILL_HANDLERS(PSDnox, 0x2d);
+    ROP3_FILL_HANDLERS(PSDPxox, 0x2e);
+    ROP3_FILL_HANDLERS(PSDnoan, 0x2f);
+    ROP3_FILL_HANDLERS(SDPnaon, 0x31);
+    ROP3_FILL_HANDLERS(SDPSoox, 0x32);
+    ROP3_FILL_HANDLERS(SPDSaox, 0x34);
+    ROP3_FILL_HANDLERS(SPDSxnox, 0x35);
+    ROP3_FILL_HANDLERS(SDPox, 0x36);
+    ROP3_FILL_HANDLERS(SDPoan, 0x37);
+    ROP3_FILL_HANDLERS(PSDPoax, 0x38);
+    ROP3_FILL_HANDLERS(SPDnox, 0x39);
+    ROP3_FILL_HANDLERS(SPDSxox, 0x3a);
+    ROP3_FILL_HANDLERS(SPDnoan, 0x3b);
+    ROP3_FILL_HANDLERS(SPDSonox, 0x3d);
+    ROP3_FILL_HANDLERS(SPDSnaox, 0x3e);
+    ROP3_FILL_HANDLERS(PSDnaa, 0x40);
+    ROP3_FILL_HANDLERS(DPSxon, 0x41);
+    ROP3_FILL_HANDLERS(SDxPDxa, 0x42);
+    ROP3_FILL_HANDLERS(SPDSanaxn, 0x43);
+    ROP3_FILL_HANDLERS(DPSnaon, 0x45);
+    ROP3_FILL_HANDLERS(DSPDaox, 0x46);
+    ROP3_FILL_HANDLERS(PSDPxaxn, 0x47);
+    ROP3_FILL_HANDLERS(SDPxa, 0x48);
+    ROP3_FILL_HANDLERS(PDSPDaoxxn, 0x49);
+    ROP3_FILL_HANDLERS(DPSDoax, 0x4a);
+    ROP3_FILL_HANDLERS(PDSnox, 0x4b);
+    ROP3_FILL_HANDLERS(SDPana, 0x4c);
+    ROP3_FILL_HANDLERS(SSPxDSxoxn, 0x4d);
+    ROP3_FILL_HANDLERS(PDSPxox, 0x4e);
+    ROP3_FILL_HANDLERS(PDSnoan, 0x4f);
+    ROP3_FILL_HANDLERS(DSPnaon, 0x51);
+    ROP3_FILL_HANDLERS(DPSDaox, 0x52);
+    ROP3_FILL_HANDLERS(SPDSxaxn, 0x53);
+    ROP3_FILL_HANDLERS(DPSonon, 0x54);
+    ROP3_FILL_HANDLERS(DPSox, 0x56);
+    ROP3_FILL_HANDLERS(DPSoan, 0x57);
+    ROP3_FILL_HANDLERS(PDSPoax, 0x58);
+    ROP3_FILL_HANDLERS(DPSnox, 0x59);
+    ROP3_FILL_HANDLERS(DPSDonox, 0x5b);
+    ROP3_FILL_HANDLERS(DPSDxox, 0x5c);
+    ROP3_FILL_HANDLERS(DPSnoan, 0x5d);
+    ROP3_FILL_HANDLERS(DPSDnaox, 0x5e);
+    ROP3_FILL_HANDLERS(PDSxa, 0x60);
+    ROP3_FILL_HANDLERS(DSPDSaoxxn, 0x61);
+    ROP3_FILL_HANDLERS(DSPDoax, 0x62);
+    ROP3_FILL_HANDLERS(SDPnox, 0x63);
+    ROP3_FILL_HANDLERS(SDPSoax, 0x64);
+    ROP3_FILL_HANDLERS(DSPnox, 0x65);
+    ROP3_FILL_HANDLERS(SDPSonox, 0x67);
+    ROP3_FILL_HANDLERS(DSPDSonoxxn, 0x68);
+    ROP3_FILL_HANDLERS(PDSxxn, 0x69);
+    ROP3_FILL_HANDLERS(DPSax, 0x6a);
+    ROP3_FILL_HANDLERS(PSDPSoaxxn, 0x6b);
+    ROP3_FILL_HANDLERS(SDPax, 0x6c);
+    ROP3_FILL_HANDLERS(PDSPDoaxxn, 0x6d);
+    ROP3_FILL_HANDLERS(SDPSnoax, 0x6e);
+    ROP3_FILL_HANDLERS(PDSxnan, 0x6f);
+    ROP3_FILL_HANDLERS(PDSana, 0x70);
+    ROP3_FILL_HANDLERS(SSDxPDxaxn, 0x71);
+    ROP3_FILL_HANDLERS(SDPSxox, 0x72);
+    ROP3_FILL_HANDLERS(SDPnoan, 0x73);
+    ROP3_FILL_HANDLERS(DSPDxox, 0x74);
+    ROP3_FILL_HANDLERS(DSPnoan, 0x75);
+    ROP3_FILL_HANDLERS(SDPSnaox, 0x76);
+    ROP3_FILL_HANDLERS(PDSax, 0x78);
+    ROP3_FILL_HANDLERS(DSPDSoaxxn, 0x79);
+    ROP3_FILL_HANDLERS(DPSDnoax, 0x7a);
+    ROP3_FILL_HANDLERS(SDPxnan, 0x7b);
+    ROP3_FILL_HANDLERS(SPDSnoax, 0x7c);
+    ROP3_FILL_HANDLERS(DPSxnan, 0x7d);
+    ROP3_FILL_HANDLERS(SPxDSxo, 0x7e);
+    ROP3_FILL_HANDLERS(DPSaan, 0x7f);
+    ROP3_FILL_HANDLERS(DPSaa, 0x80);
+    ROP3_FILL_HANDLERS(SPxDSxon, 0x81);
+    ROP3_FILL_HANDLERS(DPSxna, 0x82);
+    ROP3_FILL_HANDLERS(SPDSnoaxn, 0x83);
+    ROP3_FILL_HANDLERS(SDPxna, 0x84);
+    ROP3_FILL_HANDLERS(PDSPnoaxn, 0x85);
+    ROP3_FILL_HANDLERS(DSPDSoaxx, 0x86);
+    ROP3_FILL_HANDLERS(PDSaxn, 0x87);
+    ROP3_FILL_HANDLERS(SDPSnaoxn, 0x89);
+    ROP3_FILL_HANDLERS(DSPnoa, 0x8a);
+    ROP3_FILL_HANDLERS(DSPDxoxn, 0x8b);
+    ROP3_FILL_HANDLERS(SDPnoa, 0x8c);
+    ROP3_FILL_HANDLERS(SDPSxoxn, 0x8d);
+    ROP3_FILL_HANDLERS(SSDxPDxax, 0x8e);
+    ROP3_FILL_HANDLERS(PDSanan, 0x8f);
+    ROP3_FILL_HANDLERS(PDSxna, 0x90);
+    ROP3_FILL_HANDLERS(SDPSnoaxn, 0x91);
+    ROP3_FILL_HANDLERS(DPSDPoaxx, 0x92);
+    ROP3_FILL_HANDLERS(SPDaxn, 0x93);
+    ROP3_FILL_HANDLERS(PSDPSoaxx, 0x94);
+    ROP3_FILL_HANDLERS(DPSaxn, 0x95);
+    ROP3_FILL_HANDLERS(DPSxx, 0x96);
+    ROP3_FILL_HANDLERS(PSDPSonoxx, 0x97);
+    ROP3_FILL_HANDLERS(SDPSonoxn, 0x98);
+    ROP3_FILL_HANDLERS(DPSnax, 0x9a);
+    ROP3_FILL_HANDLERS(SDPSoaxn, 0x9b);
+    ROP3_FILL_HANDLERS(SPDnax, 0x9c);
+    ROP3_FILL_HANDLERS(DSPDoaxn, 0x9d);
+    ROP3_FILL_HANDLERS(DSPDSaoxx, 0x9e);
+    ROP3_FILL_HANDLERS(PDSxan, 0x9f);
+    ROP3_FILL_HANDLERS(PDSPnaoxn, 0xa1);
+    ROP3_FILL_HANDLERS(DPSnoa, 0xa2);
+    ROP3_FILL_HANDLERS(DPSDxoxn, 0xa3);
+    ROP3_FILL_HANDLERS(PDSPonoxn, 0xa4);
+    ROP3_FILL_HANDLERS(DSPnax, 0xa6);
+    ROP3_FILL_HANDLERS(PDSPoaxn, 0xa7);
+    ROP3_FILL_HANDLERS(DPSoa, 0xa8);
+    ROP3_FILL_HANDLERS(DPSoxn, 0xa9);
+    ROP3_FILL_HANDLERS(DPSono, 0xab);
+    ROP3_FILL_HANDLERS(SPDSxax, 0xac);
+    ROP3_FILL_HANDLERS(DPSDaoxn, 0xad);
+    ROP3_FILL_HANDLERS(DSPnao, 0xae);
+    ROP3_FILL_HANDLERS(PDSnoa, 0xb0);
+    ROP3_FILL_HANDLERS(PDSPxoxn, 0xb1);
+    ROP3_FILL_HANDLERS(SSPxDSxox, 0xb2);
+    ROP3_FILL_HANDLERS(SDPanan, 0xb3);
+    ROP3_FILL_HANDLERS(PSDnax, 0xb4);
+    ROP3_FILL_HANDLERS(DPSDoaxn, 0xb5);
+    ROP3_FILL_HANDLERS(DPSDPaoxx, 0xb6);
+    ROP3_FILL_HANDLERS(SDPxan, 0xb7);
+    ROP3_FILL_HANDLERS(PSDPxax, 0xb8);
+    ROP3_FILL_HANDLERS(DSPDaoxn, 0xb9);
+    ROP3_FILL_HANDLERS(DPSnao, 0xba);
+    ROP3_FILL_HANDLERS(SPDSanax, 0xbc);
+    ROP3_FILL_HANDLERS(SDxPDxan, 0xbd);
+    ROP3_FILL_HANDLERS(DPSxo, 0xbe);
+    ROP3_FILL_HANDLERS(DPSano, 0xbf);
+    ROP3_FILL_HANDLERS(SPDSnaoxn, 0xc1);
+    ROP3_FILL_HANDLERS(SPDSonoxn, 0xc2);
+    ROP3_FILL_HANDLERS(SPDnoa, 0xc4);
+    ROP3_FILL_HANDLERS(SPDSxoxn, 0xc5);
+    ROP3_FILL_HANDLERS(SDPnax, 0xc6);
+    ROP3_FILL_HANDLERS(PSDPoaxn, 0xc7);
+    ROP3_FILL_HANDLERS(SDPoa, 0xc8);
+    ROP3_FILL_HANDLERS(SPDoxn, 0xc9);
+    ROP3_FILL_HANDLERS(DPSDxax, 0xca);
+    ROP3_FILL_HANDLERS(SPDSaoxn, 0xcb);
+    ROP3_FILL_HANDLERS(SDPono, 0xcd);
+    ROP3_FILL_HANDLERS(SDPnao, 0xce);
+    ROP3_FILL_HANDLERS(PSDnoa, 0xd0);
+    ROP3_FILL_HANDLERS(PSDPxoxn, 0xd1);
+    ROP3_FILL_HANDLERS(PDSnax, 0xd2);
+    ROP3_FILL_HANDLERS(SPDSoaxn, 0xd3);
+    ROP3_FILL_HANDLERS(SSPxPDxax, 0xd4);
+    ROP3_FILL_HANDLERS(DPSanan, 0xd5);
+    ROP3_FILL_HANDLERS(PSDPSaoxx, 0xd6);
+    ROP3_FILL_HANDLERS(DPSxan, 0xd7);
+    ROP3_FILL_HANDLERS(PDSPxax, 0xd8);
+    ROP3_FILL_HANDLERS(SDPSaoxn, 0xd9);
+    ROP3_FILL_HANDLERS(DPSDanax, 0xda);
+    ROP3_FILL_HANDLERS(SPxDSxan, 0xdb);
+    ROP3_FILL_HANDLERS(SPDnao, 0xdc);
+    ROP3_FILL_HANDLERS(SDPxo, 0xde);
+    ROP3_FILL_HANDLERS(SDPano, 0xdf);
+    ROP3_FILL_HANDLERS(PDSoa, 0xe0);
+    ROP3_FILL_HANDLERS(PDSoxn, 0xe1);
+    ROP3_FILL_HANDLERS(DSPDxax, 0xe2);
+    ROP3_FILL_HANDLERS(PSDPaoxn, 0xe3);
+    ROP3_FILL_HANDLERS(SDPSxax, 0xe4);
+    ROP3_FILL_HANDLERS(PDSPaoxn, 0xe5);
+    ROP3_FILL_HANDLERS(SDPSanax, 0xe6);
+    ROP3_FILL_HANDLERS(SPxPDxan, 0xe7);
+    ROP3_FILL_HANDLERS(SSPxDSxax, 0xe8);
+    ROP3_FILL_HANDLERS(DSPDSanaxxn, 0xe9);
+    ROP3_FILL_HANDLERS(DPSao, 0xea);
+    ROP3_FILL_HANDLERS(DPSxno, 0xeb);
+    ROP3_FILL_HANDLERS(SDPao, 0xec);
+    ROP3_FILL_HANDLERS(SDPxno, 0xed);
+    ROP3_FILL_HANDLERS(SDPnoo, 0xef);
+    ROP3_FILL_HANDLERS(PDSono, 0xf1);
+    ROP3_FILL_HANDLERS(PDSnao, 0xf2);
+    ROP3_FILL_HANDLERS(PSDnao, 0xf4);
+    ROP3_FILL_HANDLERS(PDSxo, 0xf6);
+    ROP3_FILL_HANDLERS(PDSano, 0xf7);
+    ROP3_FILL_HANDLERS(PDSao, 0xf8);
+    ROP3_FILL_HANDLERS(PDSxno, 0xf9);
+    ROP3_FILL_HANDLERS(DPSnoo, 0xfb);
+    ROP3_FILL_HANDLERS(PSDnoo, 0xfd);
+    ROP3_FILL_HANDLERS(DPSoo, 0xfe);
+
+    for (i = 0; i < ROP3_NUM_OPS; i++) {
+        rop3_test_handlers[i]();
+    }
+}
+
+void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+                          cairo_surface_t *p, Point *pat_pos)
+{
+    rop3_with_pattern_handlers[rop3](d, s, src_pos, p, pat_pos);
+}
+
+void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+                        uint32_t rgb)
+{
+    rop3_with_color_handlers[rop3](d, s, src_pos, rgb);
+}
+
diff --git a/common/rop3.h b/common/rop3.h
new file mode 100644
index 00000000..fcf86423
--- /dev/null
+++ b/common/rop3.h
@@ -0,0 +1,33 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_ROP3
+#define _H_ROP3
+
+#include <stdint.h>
+
+#include "draw.h"
+#include "cairo.h"
+
+void do_rop3_with_pattern(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+                          cairo_surface_t *p, Point *pat_pos);
+void do_rop3_with_color(uint8_t rop3, cairo_surface_t *d, cairo_surface_t *s, Point *src_pos,
+                        uint32_t rgb);
+
+void rop3_init();
+#endif
+
diff --git a/common/vd_agent.h b/common/vd_agent.h
new file mode 100644
index 00000000..74512109
--- /dev/null
+++ b/common/vd_agent.h
@@ -0,0 +1,109 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_VD_AGENT
+#define _H_VD_AGENT
+
+#include <stdint.h>
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#endif
+
+
+typedef struct ATTR_PACKED VDAgentMessage {
+    uint32_t protocol;
+    uint32_t type;
+    uint64_t opaque;
+    uint32_t size;
+    uint8_t data[0];
+} VDAgentMessage;
+
+#define VD_AGENT_PROTOCOL 1
+
+enum {
+    VD_AGENT_MOUSE_STATE = 1,
+    VD_AGENT_MONITORS_CONFIG,
+    VD_AGENT_REPLY,
+};
+
+typedef struct ATTR_PACKED VDAgentMonConfig {
+    uint32_t height;
+    uint32_t width;
+    uint32_t depth;
+    int32_t x;
+    int32_t y;
+} VDAgentMonConfig;
+
+enum {
+    VD_AGENT_CONFIG_MONITORS_FLAG_USE_POS = (1 << 0),
+};
+
+typedef struct ATTR_PACKED VDAgentMonitorsConfig {
+    uint32_t num_of_monitors;
+    uint32_t flags;
+    VDAgentMonConfig monitors[0];
+} VDAgentMonitorsConfig;
+
+#define VD_AGENT_LBUTTON_MASK (1 << 1)
+#define VD_AGENT_MBUTTON_MASK (1 << 2)
+#define VD_AGENT_RBUTTON_MASK (1 << 3)
+#define VD_AGENT_UBUTTON_MASK (1 << 4)
+#define VD_AGENT_DBUTTON_MASK (1 << 5)
+
+typedef struct ATTR_PACKED VDAgentMouseState {
+    uint32_t x;
+    uint32_t y;
+    uint32_t buttons;
+    uint8_t display_id;
+} VDAgentMouseState;
+
+typedef struct ATTR_PACKED VDAgentReply {
+    uint32_t type;
+    uint32_t error;
+} VDAgentReply;
+
+enum {
+    VD_AGENT_SUCCESS = 1,
+    VD_AGENT_ERROR,
+};
+
+#undef ATTR_PACKED
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#endif
+
+
diff --git a/common/vdi_dev.h b/common/vdi_dev.h
new file mode 100644
index 00000000..d8b5add3
--- /dev/null
+++ b/common/vdi_dev.h
@@ -0,0 +1,97 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_VDI_DEV
+#define _H_VDI_DEV
+
+#include "ipc_ring.h"
+
+#ifdef __GNUC__
+#ifdef __i386__
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory")
+#else
+//mfence
+#define mb() __asm__ __volatile__ ("lock; addl $0,0(%%rsp)": : :"memory")
+#endif
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#define mb() __asm {lock add [esp], 0}
+#endif
+
+#define REDHAT_PCI_VENDOR_ID 0x1b36
+
+#define VDI_PORT_DEVICE_ID 0x0105
+#define VDI_PORT_REVISION 0x01
+
+#define VDI_PORT_INTERRUPT (1 << 0)
+
+#define VDI_PORT_MAGIC (*(UINT32*)"VDIP")
+
+typedef struct ATTR_PACKED VDIPortPacket {
+    UINT32 gen;
+    UINT32 size;
+    UINT8 data[512 - 2 * sizeof(UINT32)];
+} VDIPortPacket;
+
+RING_DECLARE(VDIPortRing, VDIPortPacket, 32);
+
+enum {
+    VDI_PORT_IO_RANGE_INDEX,
+    VDI_PORT_RAM_RANGE_INDEX,
+};
+
+enum {
+    VDI_PORT_IO_CONNECTION,
+    VDI_PORT_IO_NOTIFY = 4,
+    VDI_PORT_IO_UPDATE_IRQ = 8,
+
+    VDI_PORT_IO_RANGE_SIZE = 12
+};
+
+typedef struct ATTR_PACKED VDIPortRam {
+    UINT32 magic;
+    UINT32 generation;
+    UINT32 int_pending;
+    UINT32 int_mask;
+    VDIPortRing input;
+    VDIPortRing output;
+    UINT32 reserv[32];
+} VDIPortRam;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#endif
diff --git a/common/win/my_getopt-1.5/ChangeLog b/common/win/my_getopt-1.5/ChangeLog
new file mode 100644
index 00000000..a671fdb9
--- /dev/null
+++ b/common/win/my_getopt-1.5/ChangeLog
@@ -0,0 +1,22 @@
+2006-12-09  Benjamin C. W. Sittler  <bsittler@>
+
+	* my_getopt.c: add my_getopt_reset to reset the argument parser
+
+	* README: updated email address, updated for version 1.5
+
+2002-07-26  Benjamin C. W. Sittler  <bsittler@knownow.com>
+
+	* README: updated for version 1.4
+
+	* my_getopt.c: now we include <sys/types.h> explicitly for those
+	systems that narrowly (mis-)interpret ANSI C and POSIX
+	(_my_getopt_internal): added an explicit cast to size_t to make
+	g++ happy
+
+	* getopt.h, my_getopt.h: added extern "C" { ... } for C++
+	compilation (thanks to Jeff Lawson <bovine@ud.com> and others)
+
+2001-08-20  Benjamin C. W. Sittler  <bsittler@knownow.com>
+
+	* getopt.h (getopt_long_only): fixed typo (thanks to Justin Lee
+	<justin_lee@ud.com>)
diff --git a/common/win/my_getopt-1.5/LICENSE b/common/win/my_getopt-1.5/LICENSE
new file mode 100644
index 00000000..2224aba0
--- /dev/null
+++ b/common/win/my_getopt-1.5/LICENSE
@@ -0,0 +1,22 @@
+my_getopt - a command-line argument parser
+Copyright 1997-2001, Benjamin Sittler
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/common/win/my_getopt-1.5/Makefile b/common/win/my_getopt-1.5/Makefile
new file mode 100644
index 00000000..083cc4aa
--- /dev/null
+++ b/common/win/my_getopt-1.5/Makefile
@@ -0,0 +1,26 @@
+all: copy
+
+# Compiler options
+#CCOPTS = -g -O3 -Wall -Werror
+CCOPTS =
+
+# Compiler
+CC = gcc -Wall -Werror
+#CC = cc
+
+# Linker
+LD = $(CC)
+
+# Utility to remove a file
+RM = rm
+
+OBJS = main.o my_getopt.o
+
+copy: $(OBJS)
+	$(LD) -o $@ $(OBJS)
+
+clean:
+	$(RM) -f copy $(OBJS) *~
+
+%.o: %.c getopt.h my_getopt.h
+	$(CC) $(CCOPTS) -o $@ -c $<
diff --git a/common/win/my_getopt-1.5/README b/common/win/my_getopt-1.5/README
new file mode 100644
index 00000000..3a9afad7
--- /dev/null
+++ b/common/win/my_getopt-1.5/README
@@ -0,0 +1,140 @@
+my_getopt - a command-line argument parser
+Copyright 1997-2006, Benjamin Sittler
+
+The author can be reached by sending email to <bsittler@gmail.com>.
+
+The version of my_getopt in this package (1.5) has a BSD-like license;
+see the file LICENSE for details. Version 1.0 of my_getopt was similar
+to the GPL'ed version of my_getopt included with SMOKE-16 Version 1,
+Release 19990717. SMOKE-16 packages are available from:
+
+  http://geocities.com/bsittler/#smoke16
+
+OVERVIEW OF THE ARGUMENT PARSER
+===============================
+
+The getopt(), getopt_long() and getopt_long_only() functions parse
+command line arguments. The argc and argv parameters passed to these
+functions correspond to the argument count and argument list passed to
+your program's main() function at program start-up. Element 0 of the
+argument list conventionally contains the name of your program. Any
+remaining arguments starting with "-" (except for "-" or "--" by
+themselves) are option arguments, some of include option values. This
+family of getopt() functions allows intermixed option and non-option
+arguments anywhere in the argument list, except that "--" by itself
+causes the remaining elements of the argument list to be treated as
+non-option arguments.
+
+[ See the parts of this document labeled "DOCUMENTATION" and
+  "WHY RE-INVENT THE WHEEL?" for a more information. ]
+
+FILES
+=====
+
+The following four files constitute the my_getopt package:
+
+ LICENSE         - license and warranty information for my_getopt
+ my_getopt.c     - implementation of my getopt replacement
+ my_getopt.h     - interface for my getopt replacement
+ getopt.h        - a header file to make my getopt look like GNU getopt
+
+USAGE
+=====
+
+To use my_getopt in your application, include the following line to
+your main program source:
+
+ #include "getopt.h"
+
+This line should appear after your standard system header files to
+avoid conflicting with your system's built-in getopt.
+
+Then compile my_getopt.c into my_getopt.o, and link my_getopt.o into
+your application:
+
+ $ cc -c my_getopt.c
+ $ ld -o app app.o ... my_getopt.o
+
+To avoid conflicting with standard library functions, the function
+names and global variables used by my_getopt all begin with `my_'. To
+ensure compatibility with existing C programs, the `getopt.h' header
+file uses the C preprocessor to redefine names like getopt, optarg,
+optind, and so forth to my_getopt, my_optarg, my_optind, etc.
+
+SAMPLE PROGRAM
+==============
+
+There is also a public-domain sample program:
+
+ main.c          - main() for a sample program using my_getopt
+ Makefile        - build script for the sample program (called `copy')
+
+To build and test the sample program:
+
+ $ make
+ $ ./copy -help
+ $ ./copy -version
+
+The sample program bears a slight resemblance to the UNIX `cat'
+utility, but can be used rot13-encode streams, and can redirect output
+to a file.
+
+DOCUMENTATION
+=============
+
+There is not yet any real documentation for my_getopt. For the moment,
+use the Linux manual page for getopt. It has its own copyright and
+license; view the file `getopt.3' in a text editor for more details.
+
+ getopt.3        - the manual page for GNU getopt
+ getopt.txt      - preformatted copy of the manual page for GNU getopt,
+                   for your convenience
+
+WHY RE-INVENT THE WHEEL?
+========================
+
+I re-implemented getopt, getopt_long, and getopt_long_only because
+there were noticable bugs in several versions of the GNU
+implementations, and because the GNU versions aren't always available
+on some systems (*BSD, for example.) Other systems don't include any
+sort of standard argument parser (Win32 with Microsoft tools, for
+example, has no getopt.)
+
+These should do all the expected Unix- and GNU-style argument
+parsing, including permution, bunching, long options with single or
+double dashes (double dashes are required if you use
+my_getopt_long,) and optional arguments for both long and short
+options. A word with double dashes all by themselves halts argument
+parsing. A required long option argument can be in the same word as
+the option name, separated by '=', or in the next word. An optional
+long option argument must be in the same word as the option name,
+separated by '='.
+
+As with the GNU versions, a '+' prefix to the short option
+specification (or the POSIXLY_CORRECT environment variable) disables
+permution, a '-' prefix to the short option specification returns 1
+for non-options, ':' after a short option indicates a required
+argument, and '::' after a short option specification indicates an
+optional argument (which must appear in the same word.) If you'd like
+to recieve ':' instead of '?' for missing option arguments, prefix the
+short option specification with ':'.
+
+The original intent was to re-implement the documented behavior of
+the GNU versions, but I have found it necessary to emulate some of
+the undocumented behavior as well. Some programs depend on it.
+
+KNOWN BUGS
+==========
+
+The GNU versions support POSIX-style -W "name=value" long
+options. Currently, my_getopt does not support these, because I
+don't have any documentation on them (other than the fact that they
+are enabled by "W;" in the short option specification.) As a
+temporary workaround, my_getopt treats "W;" in the short option
+string identically to "W:".
+
+The GNU versions support internationalized/localized
+messages. Currently, my_getopt does not.
+
+There should be re-entrant versions of all these functions so that
+multiple threads can parse arguments simultaneously.
diff --git a/common/win/my_getopt-1.5/getopt.3 b/common/win/my_getopt-1.5/getopt.3
new file mode 100644
index 00000000..a63fcd82
--- /dev/null
+++ b/common/win/my_getopt-1.5/getopt.3
@@ -0,0 +1,288 @@
+.\" (c) 1993 by Thomas Koenig (ig25@rz.uni-karlsruhe.de)
+.\"
+.\" Permission is granted to make and distribute verbatim copies of this
+.\" manual provided the copyright notice and this permission notice are
+.\" preserved on all copies.
+.\"
+.\" Permission is granted to copy and distribute modified versions of this
+.\" manual under the conditions for verbatim copying, provided that the
+.\" entire resulting derived work is distributed under the terms of a
+.\" permission notice identical to this one
+.\" 
+.\" Since the Linux kernel and libraries are constantly changing, this
+.\" manual page may be incorrect or out-of-date.  The author(s) assume no
+.\" responsibility for errors or omissions, or for damages resulting from
+.\" the use of the information contained herein.  The author(s) may not
+.\" have taken the same level of care in the production of this manual,
+.\" which is licensed free of charge, as they might when working
+.\" professionally.
+.\" 
+.\" Formatted or processed versions of this manual, if unaccompanied by
+.\" the source, must acknowledge the copyright and authors of this work.
+.\" License.
+.\" Modified Sat Jul 24 19:27:50 1993 by Rik Faith (faith@cs.unc.edu)
+.\" Modified Mon Aug 30 22:02:34 1995 by Jim Van Zandt <jrv@vanzandt.mv.com>
+.\" longindex is a pointer, has_arg can take 3 values, using consistent
+.\" names for optstring and longindex, "\n" in formats fixed.  Documenting
+.\" opterr and getopt_long_only.  Clarified explanations (borrowing heavily
+.\" from the source code).
+.TH GETOPT 3  "Aug 30, 1995" "GNU" "Linux Programmer's Manual"
+.SH NAME
+getopt \- Parse command line options
+.SH SYNOPSIS
+.nf
+.B #include <unistd.h>
+.sp
+.BI "int getopt(int " argc ", char * const " argv[] ","
+.BI "           const char *" optstring ");"
+.sp
+.BI "extern char *" optarg ;
+.BI "extern int " optind ", " opterr ", " optopt ;
+.sp
+.B #include <getopt.h>
+.sp
+.BI "int getopt_long(int " argc ", char * const " argv[] ",
+.BI "           const char *" optstring ,
+.BI "           const struct option *" longopts ", int *" longindex ");"
+.sp
+.BI "int getopt_long_only(int " argc ", char * const " argv[] ",
+.BI "           const char *" optstring ,
+.BI "           const struct option *" longopts ", int *" longindex ");"
+.fi
+.SH DESCRIPTION
+The
+.B getopt()
+function parses the command line arguments.  Its arguments
+.I argc
+and
+.I argv
+are the argument count and array as passed to the
+.B main()
+function on program invocation.
+An element of \fIargv\fP that starts with `-' (and is not exactly "-" or "--")
+is an option element.  The characters of this element
+(aside from the initial `-') are option characters.  If \fBgetopt()\fP
+is called repeatedly, it returns successively each of the option characters
+from each of the option elements.
+.PP
+If \fBgetopt()\fP finds another option character, it returns that
+character, updating the external variable \fIoptind\fP and a static
+variable \fInextchar\fP so that the next call to \fBgetopt()\fP can
+resume the scan with the following option character or
+\fIargv\fP-element.
+.PP
+If there are no more option characters, \fBgetopt()\fP returns
+\fBEOF\fP.  Then \fIoptind\fP is the index in \fIargv\fP of the first
+\fIargv\fP-element that is not an option.
+.PP
+.I optstring
+is a string containing the legitimate option characters.  If such a
+character is followed by a colon, the option requires an argument, so
+\fBgetopt\fP places a pointer to the following text in the same
+\fIargv\fP-element, or the text of the following \fIargv\fP-element, in
+.IR optarg .
+Two colons mean an option takes
+an optional arg; if there is text in the current \fIargv\fP-element,
+it is returned in \fIoptarg\fP, otherwise \fIoptarg\fP is set to zero.
+.PP
+By default, \fBgetargs()\fP permutes the contents of \fIargv\fP as it
+scans, so that eventually all the non-options are at the end.  Two
+other modes are also implemented.  If the first character of
+\fIoptstring\fP is `+' or the environment variable POSIXLY_CORRECT is
+set, then option processing stops as soon as a non-option argument is
+encountered.  If the first character of \fIoptstring\fP is `-', then
+each non-option \fIargv\fP-element is handled as if it were the argument of
+an option with character code 1.  (This is used by programs that were
+written to expect options and other \fIargv\fP-elements in any order
+and that care about the ordering of the two.)
+The special argument `--' forces an end of option-scanning regardless
+of the scanning mode.
+.PP
+If \fBgetopt()\fP does not recognize an option character, it prints an
+error message to stderr, stores the character in \fIoptopt\fP, and
+returns `?'.  The calling program may prevent the error message by
+setting \fIopterr\fP to 0.
+.PP
+The
+.B getopt_long()
+function works like
+.B getopt()
+except that it also accepts long options, started out by two dashes.
+Long option names may be abbreviated if the abbreviation is
+unique or is an exact match for some defined option.  A long option 
+may take a parameter, of the form
+.B --arg=param
+or
+.BR "--arg param" .
+.PP
+.I longopts
+is a pointer to the first element of an array of
+.B struct option
+declared in
+.B <getopt.h>
+as
+.nf
+.sp
+.in 10
+struct option {
+.in 14
+const char *name;
+int has_arg;
+int *flag;
+int val;
+.in 10
+};
+.fi
+.PP
+The meanings of the different fields are:
+.TP
+.I name
+is the name of the long option.
+.TP
+.I has_arg
+is:
+\fBno_argument\fP (or 0) if the option does not take an argument,
+\fBrequired_argument\fP (or 1) if the option requires an argument, or
+\fBoptional_argument\fP (or 2) if the option takes an optional argument.
+.TP
+.I flag
+specifies how results are returned for a long option.  If \fIflag\fP
+is \fBNULL\fP, then \fBgetopt_long()\fP returns \fIval\fP.  (For
+example, the calling program may set \fIval\fP to the equivalent short
+option character.)  Otherwise, \fBgetopt_long()\fP returns 0, and
+\fIflag\fP points to a variable which is set to \fIval\fP if the
+option is found, but left unchanged if the option is not found.
+.TP
+\fIval\fP 
+is the value to return, or to load into the variable pointed
+to by \fIflag\fP.
+.PP
+The last element of the array has to be filled with zeroes.
+.PP
+If \fIlongindex\fP is not \fBNULL\fP, it
+points to a variable which is set to the index of the long option relative to
+.IR longopts .
+.PP
+\fBgetopt_long_only()\fP is like \fBgetopt_long()\fP, but `-' as well 
+as `--' can indicate a long option.  If an option that starts with `-'
+(not `--') doesn't match a long option, but does match a short option,
+it is parsed as a short option instead.  
+.SH "RETURN VALUE"
+The
+.B getopt()
+function returns the option character if the option was found
+successfully, `:' if there was a missing parameter for one of the
+options, `?' for an unknown option character, or \fBEOF\fP 
+for the end of the option list.
+.PP
+\fBgetopt_long()\fP and \fBgetopt_long_only()\fP also return the option
+character when a short option is recognized.  For a long option, they
+return \fIval\fP if \fIflag\fP is \fBNULL\fP, and 0 otherwise.  Error
+and EOF returns are the same as for \fBgetopt()\fP, plus `?' for an
+ambiguous match or an extraneous parameter.
+.SH "ENVIRONMENT VARIABLES"
+.TP
+.SM
+.B POSIXLY_CORRECT
+If this is set, then option processing stops as soon as a non-option 
+argument is encountered.
+.SH "EXAMPLE"
+The following example program, from the source code, illustrates the
+use of
+.BR getopt_long()
+with most of its features.
+.nf
+.sp
+#include <stdio.h>
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_optind = 0;
+
+  while (1)
+    {
+      int this_option_optind = optind ? optind : 1;
+      int option_index = 0;
+      static struct option long_options[] =
+      {
+        {"add", 1, 0, 0},
+        {"append", 0, 0, 0},
+        {"delete", 1, 0, 0},
+        {"verbose", 0, 0, 0},
+        {"create", 1, 0, 'c'},
+        {"file", 1, 0, 0},
+        {0, 0, 0, 0}
+      };
+
+      c = getopt_long (argc, argv, "abc:d:012",
+		       long_options, &option_index);
+      if (c == -1)
+	break;
+
+      switch (c)
+        {
+        case 0:
+          printf ("option %s", long_options[option_index].name);
+          if (optarg)
+            printf (" with arg %s", optarg);
+          printf ("\\n");
+          break;
+
+        case '0':
+        case '1':
+        case '2':
+          if (digit_optind != 0 && digit_optind != this_option_optind)
+            printf ("digits occur in two different argv-elements.\\n");
+          digit_optind = this_option_optind;
+          printf ("option %c\\n", c);
+          break;
+
+        case 'a':
+          printf ("option a\\n");
+          break;
+
+        case 'b':
+          printf ("option b\\n");
+          break;
+
+        case 'c':
+          printf ("option c with value `%s'\\n", optarg);
+          break;
+
+        case 'd':
+          printf ("option d with value `%s'\\n", optarg);
+          break;
+
+        case '?':
+          break;
+
+        default:
+          printf ("?? getopt returned character code 0%o ??\\n", c);
+        }
+    }
+
+  if (optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (optind < argc)
+      printf ("%s ", argv[optind++]);
+      printf ("\\n");
+    }
+
+  exit (0);
+}
+.fi
+.SH "BUGS"
+This manpage is confusing.
+.SH "CONFORMING TO"
+.TP
+\fBgetopt()\fP:
+POSIX.1, provided the environment variable POSIXLY_CORRECT is set.
+Otherwise, the elements of \fIargv\fP aren't really const, because we
+permute them.  We pretend they're const in the prototype to be
+compatible with other systems.
+
diff --git a/common/win/my_getopt-1.5/getopt.h b/common/win/my_getopt-1.5/getopt.h
new file mode 100644
index 00000000..5f08ccb4
--- /dev/null
+++ b/common/win/my_getopt-1.5/getopt.h
@@ -0,0 +1,56 @@
+/*
+ *  getopt.h - cpp wrapper for my_getopt to make it look like getopt.
+ *  Copyright 1997, 2000, 2001, 2002, Benjamin Sittler
+ *
+ *  Permission is hereby granted, free of charge, to any person
+ *  obtaining a copy of this software and associated documentation
+ *  files (the "Software"), to deal in the Software without
+ *  restriction, including without limitation the rights to use, copy,
+ *  modify, merge, publish, distribute, sublicense, and/or sell copies
+ *  of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef MY_WRAPPER_GETOPT_H_INCLUDED
+#define MY_WRAPPER_GETOPT_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "my_getopt.h"
+
+#undef getopt
+#define getopt my_getopt
+#undef getopt_long
+#define getopt_long my_getopt_long
+#undef getopt_long_only
+#define getopt_long_only my_getopt_long_only
+#undef _getopt_internal
+#define _getopt_internal _my_getopt_internal
+#undef opterr
+#define opterr my_opterr
+#undef optind
+#define optind my_optind
+#undef optopt
+#define optopt my_optopt
+#undef optarg
+#define optarg my_optarg
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MY_WRAPPER_GETOPT_H_INCLUDED */
diff --git a/common/win/my_getopt-1.5/getopt.txt b/common/win/my_getopt-1.5/getopt.txt
new file mode 100644
index 00000000..ae08824e
--- /dev/null
+++ b/common/win/my_getopt-1.5/getopt.txt
@@ -0,0 +1,330 @@
+
+
+
+GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
+
+
+NAME
+       getopt - Parse command line options
+
+SYNOPSIS
+       #include <unistd.h>
+
+       int getopt(int argc, char * const argv[],
+                  const char *optstring);
+
+       extern char *optarg;
+       extern int optind, opterr, optopt;
+
+       #include <getopt.h>
+
+       int getopt_long(int argc, char * const argv[],
+                  const char *optstring,
+                  const struct option *longopts, int *longindex);
+
+       int getopt_long_only(int argc, char * const argv[],
+                  const char *optstring,
+                  const struct option *longopts, int *longindex);
+
+DESCRIPTION
+       The  getopt()  function parses the command line arguments.
+       Its arguments argc and argv are  the  argument  count  and
+       array  as passed to the main() function on program invoca-
+       tion.  An element of argv that starts with `-' (and is not
+       exactly "-" or "--") is an option element.  The characters
+       of this element (aside from the initial  `-')  are  option
+       characters.   If getopt() is called repeatedly, it returns
+       successively each of the option characters  from  each  of
+       the option elements.
+
+       If  getopt()  finds  another  option character, it returns
+       that character, updating the external variable optind  and
+       a  static  variable  nextchar  so  that  the  next call to
+       getopt() can resume the scan  with  the  following  option
+       character or argv-element.
+
+       If  there  are no more option characters, getopt() returns
+       EOF.  Then optind is the index in argv of the first  argv-
+       element that is not an option.
+
+       optstring  is  a  string  containing the legitimate option
+       characters.  If such a character is followed by  a  colon,
+       the  option  requires  an  argument,  so  getopt  places a
+       pointer to the following text in the same argv-element, or
+       the  text  of  the following argv-element, in optarg.  Two
+       colons mean an option takes an optional arg; if  there  is
+       text  in  the  current  argv-element,  it  is  returned in
+       optarg, otherwise optarg is set to zero.
+
+       By default, getargs() permutes the contents of argv as  it
+       scans,  so  that eventually all the non-options are at the
+
+
+
+GNU                        Aug 30, 1995                         1
+
+
+
+
+
+GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
+
+
+       end.  Two other modes are also implemented.  If the  first
+       character  of optstring is `+' or the environment variable
+       POSIXLY_CORRECT is set, then option  processing  stops  as
+       soon  as  a  non-option  argument  is encountered.  If the
+       first character of optstring is `-', then each  non-option
+       argv-element  is  handled as if it were the argument of an
+       option with character code 1.  (This is used  by  programs
+       that  were  written  to expect options and other argv-ele-
+       ments in any order and that care about the ordering of the
+       two.)   The special argument `--' forces an end of option-
+       scanning regardless of the scanning mode.
+
+       If getopt() does not recognize  an  option  character,  it
+       prints an error message to stderr, stores the character in
+       optopt, and returns `?'.  The calling program may  prevent
+       the error message by setting opterr to 0.
+
+       The getopt_long() function works like getopt() except that
+       it also accepts long options, started out by  two  dashes.
+       Long  option  names may be abbreviated if the abbreviation
+       is unique or is an exact match for some defined option.  A
+       long  option may take a parameter, of the form --arg=param
+       or --arg param.
+
+       longopts is a pointer to the first element of an array  of
+       struct option declared in <getopt.h> as
+
+          struct option {
+              const char *name;
+              int has_arg;
+              int *flag;
+              int val;
+          };
+
+       The meanings of the different fields are:
+
+       name   is the name of the long option.
+
+       has_arg
+              is:  no_argument (or 0) if the option does not take
+              an argument, required_argument (or 1) if the option
+              requires  an  argument, or optional_argument (or 2)
+              if the option takes an optional argument.
+
+       flag   specifies how  results  are  returned  for  a  long
+              option.    If  flag  is  NULL,  then  getopt_long()
+              returns val.  (For example, the calling program may
+              set  val to the equivalent short option character.)
+              Otherwise, getopt_long() returns 0, and flag points
+              to  a variable which is set to val if the option is
+              found, but left unchanged  if  the  option  is  not
+              found.
+
+       val    is  the  value  to  return,  or  to  load  into the
+
+
+
+GNU                        Aug 30, 1995                         2
+
+
+
+
+
+GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
+
+
+              variable pointed to by flag.
+
+       The last element of  the  array  has  to  be  filled  with
+       zeroes.
+
+       If longindex is not NULL, it points to a variable which is
+       set to the index of the long option relative to  longopts.
+
+       getopt_long_only()  is like getopt_long(), but `-' as well
+       as `--' can indicate a long option.   If  an  option  that
+       starts  with  `-'  (not `--') doesn't match a long option,
+       but does match a short option, it is  parsed  as  a  short
+       option instead.
+
+RETURN VALUE
+       The  getopt() function returns the option character if the
+       option was found successfully, `:' if there was a  missing
+       parameter  for  one  of  the  options,  `?' for an unknown
+       option character, or EOF for the end of the option list.
+
+       getopt_long()  and  getopt_long_only()  also  return   the
+       option character when a short option is recognized.  For a
+       long option, they return val if flag is NULL, and 0 other-
+       wise.  Error and EOF returns are the same as for getopt(),
+       plus `?' for an ambiguous match or an  extraneous  parame-
+       ter.
+
+ENVIRONMENT VARIABLES
+       POSIXLY_CORRECT
+              If  this  is  set,  then option processing stops as
+              soon as a non-option argument is encountered.
+
+EXAMPLE
+       The following  example  program,  from  the  source  code,
+       illustrates the use of getopt_long() with most of its fea-
+       tures.
+
+       #include <stdio.h>
+
+       int
+       main (argc, argv)
+            int argc;
+            char **argv;
+       {
+         int c;
+         int digit_optind = 0;
+
+         while (1)
+           {
+             int this_option_optind = optind ? optind : 1;
+             int option_index = 0;
+             static struct option long_options[] =
+             {
+               {"add", 1, 0, 0},
+
+
+
+GNU                        Aug 30, 1995                         3
+
+
+
+
+
+GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
+
+
+               {"append", 0, 0, 0},
+               {"delete", 1, 0, 0},
+               {"verbose", 0, 0, 0},
+               {"create", 1, 0, 'c'},
+               {"file", 1, 0, 0},
+               {0, 0, 0, 0}
+             };
+
+             c = getopt_long (argc, argv, "abc:d:012",
+                        long_options, &option_index);
+             if (c == -1)
+            break;
+
+             switch (c)
+               {
+               case 0:
+                 printf ("option %s", long_options[option_index].name);
+                 if (optarg)
+                   printf (" with arg %s", optarg);
+                 printf ("\n");
+                 break;
+
+               case '0':
+               case '1':
+               case '2':
+                 if (digit_optind != 0 && digit_optind != this_option_optind)
+                   printf ("digits occur in two different argv-elements.\n");
+                 digit_optind = this_option_optind;
+                 printf ("option %c\n", c);
+                 break;
+
+               case 'a':
+                 printf ("option a\n");
+                 break;
+
+               case 'b':
+                 printf ("option b\n");
+                 break;
+
+               case 'c':
+                 printf ("option c with value `%s'\n", optarg);
+                 break;
+
+               case 'd':
+                 printf ("option d with value `%s'\n", optarg);
+                 break;
+
+               case '?':
+                 break;
+
+               default:
+                 printf ("?? getopt returned character code 0%o ??\n", c);
+               }
+           }
+
+
+
+GNU                        Aug 30, 1995                         4
+
+
+
+
+
+GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
+
+
+         if (optind < argc)
+           {
+             printf ("non-option ARGV-elements: ");
+             while (optind < argc)
+             printf ("%s ", argv[optind++]);
+             printf ("\n");
+           }
+
+         exit (0);
+       }
+
+BUGS
+       This manpage is confusing.
+
+CONFORMING TO
+       getopt():
+              POSIX.1,   provided   the   environment    variable
+              POSIXLY_CORRECT is set.  Otherwise, the elements of
+              argv aren't really const, because we permute  them.
+              We  pretend  they're  const  in the prototype to be
+              compatible with other systems.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+GNU                        Aug 30, 1995                         5
+
+
diff --git a/common/win/my_getopt-1.5/main.c b/common/win/my_getopt-1.5/main.c
new file mode 100644
index 00000000..25674e1c
--- /dev/null
+++ b/common/win/my_getopt-1.5/main.c
@@ -0,0 +1,387 @@
+/*
+ * copy - test program for my getopt() re-implementation
+ *
+ * This program is in the public domain.
+ */
+
+#define VERSION \
+"0.3"
+
+#define COPYRIGHT \
+"This program is in the public domain."
+
+/* for isprint(), printf(), fopen(), perror(), getenv(), strcmp(), etc. */
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* for my getopt() re-implementation */
+#include "getopt.h"
+
+/* the default verbosity level is 0 (no verbose reporting) */
+static unsigned verbose = 0;
+
+/* print version and copyright information */
+static void
+version(char *progname)
+{
+  printf("%s version %s\n"
+         "%s\n",
+         progname,
+         VERSION,
+         COPYRIGHT);
+}
+
+/* print a help summary */
+static void
+help(char *progname)
+{
+  printf("Usage: %s [options] [FILE]...\n"
+         "Options:\n"
+         "-h or -help             show this message and exit\n"
+         "-append                 append to the output file\n"
+         "-o FILE or\n"
+         "-output FILE            send output to FILE (default is stdout)\n"
+         "-r or --rotate          rotate letters 13 positions (rot13)\n"
+         "-rNUM or\n"
+         "--rotate=NUM            rotate letters NUM positions\n"
+         "-truncate               truncate the output file "
+                                 "(this is the default)\n"
+         "-v or -verbose          increase the level of verbosity by 1"
+                                 "(the default is 0)\n"
+         "-vNUM or\n"
+         "-verbose=NUM            set the level of verbosity to NUM\n"
+         "-V or -version          print program version and exit\n"
+         "\n"
+         "This program reads the specified FILEs "
+         "(or stdin if none are given)\n"
+         "and writes their bytes to the specified output FILE "
+         "(or stdout if none is\n"
+         "given.) It can optionally rotate letters.\n",
+         progname);
+}
+
+/* print usage information to stderr */
+static void
+usage(char *progname)
+{
+  fprintf(stderr,
+          "Summary: %s [-help] [-version] [options] [FILE]...\n",
+          progname);
+}
+
+/* input file handler -- returns nonzero or exit()s on failure */
+static int
+handle(char *progname,
+       FILE *infile,  char *infilename,
+       FILE *outfile, char *outfilename,
+       int rotate)
+{
+  int c;
+  unsigned long bytes_copied = 0;
+
+  if (verbose > 2)
+    {
+      fprintf(stderr,
+              "%s: copying from `%s' to `%s'\n",
+              progname,
+              infilename,
+              outfilename);
+    }
+  while ((c = getc(infile)) != EOF)
+    {
+      if (rotate && isalpha(c))
+        {
+          const char *letters = "abcdefghijklmnopqrstuvwxyz";
+          char *match;
+          if ((match = strchr(letters, tolower(c))))
+            {
+              char rc = letters[(match - letters + rotate) % 26];
+              if (isupper(c))
+                rc = toupper(rc);
+              c = rc;
+            }
+        }
+      if (putc(c, outfile) == EOF)
+        {
+          perror(outfilename);
+          exit(1);
+        }
+      bytes_copied ++;
+    }
+  if (! feof(infile))
+    {
+      perror(infilename);
+      return 1;
+    }
+  if (verbose > 2)
+    {
+      fprintf(stderr,
+              "%s: %lu bytes copied from `%s' to `%s'\n",
+              progname,
+              bytes_copied,
+              infilename,
+              outfilename);
+    }
+  return 0;
+}
+
+/* argument parser and dispatcher */
+int
+main(int argc, char * argv[])
+{
+  /* the program name */
+  char *progname = argv[0];
+  /* during argument parsing, opt contains the return value from getopt() */
+  int opt;
+  /* the output filename is initially 0 (a.k.a. stdout) */
+  char *outfilename = 0;
+  /* the default return value is initially 0 (success) */
+  int retval = 0;
+  /* initially we truncate */
+  int append = 0;
+  /* initially we don't rotate letters */
+  int rotate = 0;
+
+  /* short options string */
+  char *shortopts = "Vho:r::v::";
+  /* long options list */
+  struct option longopts[] =
+  {
+    /* name,        has_arg,           flag, val */ /* longind */
+    { "append",     no_argument,       0,     0  }, /*       0 */
+    { "truncate",   no_argument,       0,     0  }, /*       1 */
+    { "version",    no_argument,       0,    'V' }, /*       3 */
+    { "help",       no_argument,       0,    'h' }, /*       4 */
+    { "output",     required_argument, 0,    'o' }, /*       5 */
+    { "rotate",     optional_argument, 0,    'r' }, /*       6 */
+    { "verbose",    optional_argument, 0,    'v' }, /*       7 */
+    /* end-of-list marker */
+    { 0, 0, 0, 0 }
+  };
+  /* long option list index */
+  int longind = 0;
+
+  /* 
+   * print a warning when the POSIXLY_CORRECT environment variable will
+   * interfere with argument placement
+   */
+  if (getenv("POSIXLY_CORRECT"))
+    {
+      fprintf(stderr,
+              "%s: "
+              "Warning: implicit argument reordering disallowed by "
+              "POSIXLY_CORRECT\n",
+              progname);
+    }
+
+  /* parse all options from the command line */
+  while ((opt =
+          getopt_long_only(argc, argv, shortopts, longopts, &longind)) != -1)
+    switch (opt)
+      {
+      case 0: /* a long option without an equivalent short option */
+        switch (longind)
+          {
+          case 0: /* -append */
+            append = 1;
+            break;
+          case 1: /* -truncate */
+            append = 0;
+            break;
+          default: /* something unexpected has happened */
+            fprintf(stderr,
+                    "%s: "
+                    "getopt_long_only unexpectedly returned %d for `--%s'\n",
+                    progname,
+                    opt,
+                    longopts[longind].name);
+            return 1;
+          }
+        break;
+      case 'V': /* -version */
+        version(progname);
+        return 0;
+      case 'h': /* -help */
+        help(progname);
+        return 0;
+      case 'r': /* -rotate[=NUM] */
+        if (optarg)
+          {
+            /* we use this while trying to parse a numeric argument */
+            char ignored;
+            if (sscanf(optarg,
+                       "%d%c",
+                       &rotate,
+                       &ignored) != 1)
+              {
+                fprintf(stderr,
+                        "%s: "
+                        "rotation `%s' is not a number\n",
+                        progname,
+                        optarg);
+                usage(progname);
+                return 2;
+              }
+            /* normalize rotation */
+            while (rotate < 0)
+              {
+                rotate += 26;
+              }
+            rotate %= 26;
+          }
+        else
+          rotate = 13;
+        break;
+      case 'o': /* -output=FILE */
+        outfilename = optarg;
+        /* we allow "-" as a synonym for stdout here */
+        if (! strcmp(optarg, "-"))
+          {
+            outfilename = 0;
+          }
+        break;
+      case 'v': /* -verbose[=NUM] */
+        if (optarg)
+          {
+            /* we use this while trying to parse a numeric argument */
+            char ignored;
+            if (sscanf(optarg,
+                       "%u%c",
+                       &verbose,
+                       &ignored) != 1)
+              {
+                fprintf(stderr,
+                        "%s: "
+                        "verbosity level `%s' is not a number\n",
+                        progname,
+                        optarg);
+                usage(progname);
+                return 2;
+              }
+          }
+        else
+          verbose ++;
+        break;
+      case '?': /* getopt_long_only noticed an error */
+        usage(progname);
+        return 2;
+      default: /* something unexpected has happened */
+        fprintf(stderr,
+                "%s: "
+                "getopt_long_only returned an unexpected value (%d)\n",
+                progname,
+                opt);
+        return 1;
+      }
+
+  /* re-open stdout to outfilename, if requested */
+  if (outfilename)
+    {
+      if (! freopen(outfilename, (append ? "a" : "w"), stdout))
+        {
+          perror(outfilename);
+          return 1;
+        }
+    }
+  else
+    {
+      /* make a human-readable version of the output filename "-" */
+      outfilename = "stdout";
+      /* you can't truncate stdout */
+      append = 1;
+    }
+
+  if (verbose)
+    {
+      fprintf(stderr,
+              "%s: verbosity level is %u; %s `%s'; rotation %d\n",
+              progname,
+              verbose,
+              (append ? "appending to" : "truncating"),
+              outfilename,
+              rotate);
+    }
+
+  if (verbose > 1)
+    {
+      fprintf(stderr,
+              "%s: %d input file(s) were given\n",
+              progname,
+              ((argc > optind) ? (argc - optind) : 0));
+    }
+
+  if (verbose > 3)
+  {
+      fprintf(stderr,
+              "\topterr: %d\n\toptind: %d\n\toptopt: %d (%c)\n\toptarg: %s\n",
+              opterr,
+              optind,
+              optopt, optopt,
+              optarg ? optarg : "(null)");
+  }
+
+  /* handle each of the input files (or stdin, if no files were given) */
+  if (optind < argc)
+    {
+      int argindex;
+      
+      for (argindex = optind; argindex < argc; argindex ++)
+        {
+          char *infilename = argv[argindex];
+          FILE *infile;
+          
+          /* we allow "-" as a synonym for stdin here */
+          if (! strcmp(infilename, "-"))
+            {
+              infile = stdin;
+              infilename = "stdin";
+            }
+          else if (! (infile = fopen(infilename, "r")))
+            {
+              perror(infilename);
+              retval = 1;
+              continue;
+            }
+          if (handle(progname,
+                     infile, argv[optind],
+                     stdout, outfilename,
+                     rotate))
+            {
+              retval = 1;
+              fclose(infile);
+              continue;
+            }
+          if ((infile != stdin) && fclose(infile))
+            {
+              perror(infilename);
+              retval = 1;
+            }
+        }
+    }
+  else
+    {
+      retval =
+        handle(progname,
+               stdin, "stdin",
+               stdout, outfilename,
+               rotate);
+    }
+
+  /* close stdout */
+  if (fclose(stdout))
+    {
+      perror(outfilename);
+      return 1;
+    }
+
+  if (verbose > 3)
+    {
+      fprintf(stderr,
+              "%s: normal return, exit code is %d\n",
+              progname,
+              retval);
+    }
+  return retval;
+}
diff --git a/common/win/my_getopt-1.5/my_getopt.c b/common/win/my_getopt-1.5/my_getopt.c
new file mode 100644
index 00000000..e3737df8
--- /dev/null
+++ b/common/win/my_getopt-1.5/my_getopt.c
@@ -0,0 +1,281 @@
+/*
+ *  my_getopt.c - my re-implementation of getopt.
+ *  Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
+ *
+ *  Permission is hereby granted, free of charge, to any person
+ *  obtaining a copy of this software and associated documentation
+ *  files (the "Software"), to deal in the Software without
+ *  restriction, including without limitation the rights to use, copy,
+ *  modify, merge, publish, distribute, sublicense, and/or sell copies
+ *  of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "my_getopt.h"
+
+int my_optind=1, my_opterr=1, my_optopt=0;
+char *my_optarg=0;
+
+/* reset argument parser to start-up values */
+int my_getopt_reset(void)
+{
+    my_optind = 1;
+    my_opterr = 1;
+    my_optopt = 0;
+    my_optarg = 0;
+    return 0;
+}
+
+/* this is the plain old UNIX getopt, with GNU-style extensions. */
+/* if you're porting some piece of UNIX software, this is all you need. */
+/* this supports GNU-style permution and optional arguments */
+
+int my_getopt(int argc, char * argv[], const char *opts)
+{
+  static int charind=0;
+  char mode, colon_mode;
+  int off = 0, opt = -1;
+
+  if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
+  else {
+    if((colon_mode = *opts) == ':') off ++;
+    if(((mode = opts[off]) == '+') || (mode == '-')) {
+      off++;
+      if((colon_mode != ':') && ((colon_mode = opts[off]) == ':'))
+        off ++;
+    }
+  }
+  my_optarg = 0;
+  if(charind) {
+    const char *s;
+    my_optopt = argv[my_optind][charind];
+    for(s=opts+off; *s; s++) if(my_optopt == *s) {
+      charind++;
+      if((*(++s) == ':') || ((my_optopt == 'W') && (*s == ';'))) {
+        if(argv[my_optind][charind]) {
+          my_optarg = &(argv[my_optind++][charind]);
+          charind = 0;
+        } else if(*(++s) != ':') {
+          charind = 0;
+          if(++my_optind >= argc) {
+            if(my_opterr) fprintf(stderr,
+                                "%s: option requires an argument -- %c\n",
+                                argv[0], my_optopt);
+            opt = (colon_mode == ':') ? ':' : '?';
+            goto my_getopt_ok;
+          }
+          my_optarg = argv[my_optind++];
+        }
+      }
+      opt = my_optopt;
+      goto my_getopt_ok;
+    }
+    if(my_opterr) fprintf(stderr,
+                        "%s: illegal option -- %c\n",
+                        argv[0], my_optopt);
+    opt = '?';
+    if(argv[my_optind][++charind] == '\0') {
+      my_optind++;
+      charind = 0;
+    }
+  my_getopt_ok:
+    if(charind && ! argv[my_optind][charind]) {
+      my_optind++;
+      charind = 0;
+    }
+  } else if((my_optind >= argc) ||
+             ((argv[my_optind][0] == '-') &&
+              (argv[my_optind][1] == '-') &&
+              (argv[my_optind][2] == '\0'))) {
+    my_optind++;
+    opt = -1;
+  } else if((argv[my_optind][0] != '-') ||
+             (argv[my_optind][1] == '\0')) {
+    char *tmp;
+    int i, j, k;
+
+    if(mode == '+') opt = -1;
+    else if(mode == '-') {
+      my_optarg = argv[my_optind++];
+      charind = 0;
+      opt = 1;
+    } else {
+      for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
+                                        (argv[i][1] != '\0')) {
+        my_optind=i;
+        opt=my_getopt(argc, argv, opts);
+        while(i > j) {
+          tmp=argv[--i];
+          for(k=i; k+1<my_optind; k++) argv[k]=argv[k+1];
+          argv[--my_optind]=tmp;
+        }
+        break;
+      }
+      if(i == argc) opt = -1;
+    }
+  } else {
+    charind++;
+    opt = my_getopt(argc, argv, opts);
+  }
+  if (my_optind > argc) my_optind = argc;
+  return opt;
+}
+
+/* this is the extended getopt_long{,_only}, with some GNU-like
+ * extensions. Implements _getopt_internal in case any programs
+ * expecting GNU libc getopt call it.
+ */
+
+int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
+                     const struct option *longopts, int *longind,
+                     int long_only)
+{
+  char mode, colon_mode = *shortopts;
+  int shortoff = 0, opt = -1;
+
+  if(getenv("POSIXLY_CORRECT")) colon_mode = mode = '+';
+  else {
+    if((colon_mode = *shortopts) == ':') shortoff ++;
+    if(((mode = shortopts[shortoff]) == '+') || (mode == '-')) {
+      shortoff++;
+      if((colon_mode != ':') && ((colon_mode = shortopts[shortoff]) == ':'))
+        shortoff ++;
+    }
+  }
+  my_optarg = 0;
+  if((my_optind >= argc) ||
+      ((argv[my_optind][0] == '-') &&
+       (argv[my_optind][1] == '-') &&
+       (argv[my_optind][2] == '\0'))) {
+    my_optind++;
+    opt = -1;
+  } else if((argv[my_optind][0] != '-') ||
+            (argv[my_optind][1] == '\0')) {
+    char *tmp;
+    int i, j, k;
+
+    opt = -1;
+    if(mode == '+') return -1;
+    else if(mode == '-') {
+      my_optarg = argv[my_optind++];
+      return 1;
+    }
+    for(i=j=my_optind; i<argc; i++) if((argv[i][0] == '-') &&
+                                    (argv[i][1] != '\0')) {
+      my_optind=i;
+      opt=_my_getopt_internal(argc, argv, shortopts,
+                              longopts, longind,
+                              long_only);
+      while(i > j) {
+        tmp=argv[--i];
+        for(k=i; k+1<my_optind; k++)
+          argv[k]=argv[k+1];
+        argv[--my_optind]=tmp;
+      }
+      break;
+    }
+  } else if((!long_only) && (argv[my_optind][1] != '-'))
+    opt = my_getopt(argc, argv, shortopts);
+  else {
+    int charind, offset;
+    int found = 0, ind, hits = 0;
+
+    if(((my_optopt = argv[my_optind][1]) != '-') && ! argv[my_optind][2]) {
+      int c;
+      
+      ind = shortoff;
+      while((c = shortopts[ind++])) {
+        if(((shortopts[ind] == ':') ||
+            ((c == 'W') && (shortopts[ind] == ';'))) &&
+           (shortopts[++ind] == ':'))
+          ind ++;
+        if(my_optopt == c) return my_getopt(argc, argv, shortopts);
+      }
+    }
+    offset = 2 - (argv[my_optind][1] != '-');
+    for(charind = offset;
+        (argv[my_optind][charind] != '\0') &&
+          (argv[my_optind][charind] != '=');
+        charind++);
+    for(ind = 0; longopts[ind].name && !hits; ind++)
+      if((strlen(longopts[ind].name) == (size_t) (charind - offset)) &&
+         (strncmp(longopts[ind].name,
+                  argv[my_optind] + offset, charind - offset) == 0))
+        found = ind, hits++;
+    if(!hits) for(ind = 0; longopts[ind].name; ind++)
+      if(strncmp(longopts[ind].name,
+                 argv[my_optind] + offset, charind - offset) == 0)
+        found = ind, hits++;
+    if(hits == 1) {
+      opt = 0;
+
+      if(argv[my_optind][charind] == '=') {
+        if(longopts[found].has_arg == 0) {
+          opt = '?';
+          if(my_opterr) fprintf(stderr,
+                             "%s: option `--%s' doesn't allow an argument\n",
+                             argv[0], longopts[found].name);
+        } else {
+          my_optarg = argv[my_optind] + ++charind;
+          charind = 0;
+        }
+      } else if(longopts[found].has_arg == 1) {
+        if(++my_optind >= argc) {
+          opt = (colon_mode == ':') ? ':' : '?';
+          if(my_opterr) fprintf(stderr,
+                             "%s: option `--%s' requires an argument\n",
+                             argv[0], longopts[found].name);
+        } else my_optarg = argv[my_optind];
+      }
+      if(!opt) {
+        if (longind) *longind = found;
+        if(!longopts[found].flag) opt = longopts[found].val;
+        else *(longopts[found].flag) = longopts[found].val;
+      }
+      my_optind++;
+    } else if(!hits) {
+      if(offset == 1) opt = my_getopt(argc, argv, shortopts);
+      else {
+        opt = '?';
+        if(my_opterr) fprintf(stderr,
+                           "%s: unrecognized option `%s'\n",
+                           argv[0], argv[my_optind++]);
+      }
+    } else {
+      opt = '?';
+      if(my_opterr) fprintf(stderr,
+                         "%s: option `%s' is ambiguous\n",
+                         argv[0], argv[my_optind++]);
+    }
+  }
+  if (my_optind > argc) my_optind = argc;
+  return opt;
+}
+
+int my_getopt_long(int argc, char * argv[], const char *shortopts,
+                const struct option *longopts, int *longind)
+{
+  return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 0);
+}
+
+int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
+                const struct option *longopts, int *longind)
+{
+  return _my_getopt_internal(argc, argv, shortopts, longopts, longind, 1);
+}
diff --git a/common/win/my_getopt-1.5/my_getopt.h b/common/win/my_getopt-1.5/my_getopt.h
new file mode 100644
index 00000000..2c1dd66f
--- /dev/null
+++ b/common/win/my_getopt-1.5/my_getopt.h
@@ -0,0 +1,72 @@
+/*
+ *  my_getopt.h - interface to my re-implementation of getopt.
+ *  Copyright 1997, 2000, 2001, 2002, 2006, Benjamin Sittler
+ *
+ *  Permission is hereby granted, free of charge, to any person
+ *  obtaining a copy of this software and associated documentation
+ *  files (the "Software"), to deal in the Software without
+ *  restriction, including without limitation the rights to use, copy,
+ *  modify, merge, publish, distribute, sublicense, and/or sell copies
+ *  of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *  
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *  
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ *  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ *  WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ *  DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef MY_GETOPT_H_INCLUDED
+#define MY_GETOPT_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* reset argument parser to start-up values */
+extern int my_getopt_reset(void);
+
+/* UNIX-style short-argument parser */
+extern int my_getopt(int argc, char * argv[], const char *opts);
+
+extern int my_optind, my_opterr, my_optopt;
+extern char *my_optarg;
+
+struct option {
+  const char *name;
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* human-readable values for has_arg */
+#undef no_argument
+#define no_argument 0
+#undef required_argument
+#define required_argument 1
+#undef optional_argument
+#define optional_argument 2
+
+/* GNU-style long-argument parsers */
+extern int my_getopt_long(int argc, char * argv[], const char *shortopts,
+                       const struct option *longopts, int *longind);
+
+extern int my_getopt_long_only(int argc, char * argv[], const char *shortopts,
+                            const struct option *longopts, int *longind);
+
+extern int _my_getopt_internal(int argc, char * argv[], const char *shortopts,
+                            const struct option *longopts, int *longind,
+                            int long_only);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MY_GETOPT_H_INCLUDED */
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 00000000..25a2f034
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,321 @@
+AC_PREREQ([2.57])
+
+m4_define([SPICE_MAJOR], 0)
+m4_define([SPICE_MINOR], 3)
+m4_define([SPICE_MICRO], 99)
+
+AC_INIT(spice, [SPICE_MAJOR.SPICE_MINOR.SPICE_MICRO], [], spice)
+
+AC_CONFIG_MACRO_DIR([m4])
+AM_CONFIG_HEADER([config.h])
+AC_CONFIG_AUX_DIR(.)
+
+AM_INIT_AUTOMAKE([dist-bzip2])
+AM_MAINTAINER_MODE
+
+AS_IF([test "$CFLAGS" = ""], [], [_cflags_is_set=yes])
+AC_PROG_CC
+AS_IF([test "$CXXFLAGS" = ""], [], [_cxxflags_is_set=yes])
+AC_PROG_CXX
+AC_PROG_INSTALL
+AC_CANONICAL_HOST
+AC_PROG_LIBTOOL
+AM_PROG_CC_C_O
+
+SPICE_LT_VERSION=m4_format("%d:%d:%d", SPICE_MAJOR, SPICE_MINOR, SPICE_MICRO)
+AC_SUBST(SPICE_LT_VERSION)
+
+# Check for the CPU we are using
+#
+AC_MSG_CHECKING(for x86 or x86-64 platform)
+case $host_cpu in
+  i386|i486|i586|i686|i786|k6|k7)
+	variant=32
+        ;;
+  x86_64)
+	variant=64
+	;;
+  *)
+	AC_MSG_RESULT(no)
+	echo Only x86 and x86-64 are supported
+	exit 1
+esac
+AC_MSG_RESULT($variant bit)
+AM_CONDITIONAL([X86_64], [test "$variant" = 64])
+
+AC_MSG_CHECKING([for native Win32])
+case "$host" in
+  *-*-mingw*)
+    os_win32=yes
+    ;;
+  *)
+    os_win32=no
+    ;;
+esac
+AC_MSG_RESULT([$os_win32])
+
+case $host in
+  *-*-linux*)
+    os_linux=yes
+    ;;
+esac
+
+dnl =========================================================================
+dnl Check OS target
+
+AC_MSG_CHECKING([for some Win32 platform])
+case "$host" in
+  *-*-mingw*|*-*-cygwin*)
+    platform_win32=yes
+    ;;
+  *)
+    platform_win32=no
+    ;;
+esac
+AC_MSG_RESULT([$platform_win32])
+if test "$platform_win32" = yes; then
+  red_target=windows
+else
+  red_target=x11
+fi
+AC_SUBST(red_target)
+
+AM_CONDITIONAL(OS_WIN32, test "$os_win32" = "yes")
+AM_CONDITIONAL(OS_UNIX, test "$os_win32" != "yes")
+AM_CONDITIONAL(OS_LINUX, test "$os_linux" = "yes")
+
+dnl =========================================================================
+dnl Check deps
+
+AC_CHECK_LIBM
+AC_SUBST(LIBM)
+
+AC_CHECK_LIB(rt, clock_gettime,
+   AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [Defined if we have clock_gettime()])
+   LIBRT=-lrt
+   )
+AC_SUBST(LIBRT)
+
+SPICE_NONPKGCONFIG_LIBS+=" $LIBM $LIBRT"
+
+SPICE_REQUIRES=""
+
+PKG_CHECK_MODULES(LOG4CPP, log4cpp)
+AC_SUBST(LOG4CPP_CFLAGS)
+AC_SUBST(LOG4CPP_LIBS)
+SPICE_REQUIRES+=" log4cpp"
+
+PKG_CHECK_MODULES(QCAIRO, qcairo >= 1.4.6)
+AC_SUBST(QCAIRO_CFLAGS)
+AC_SUBST(QCAIRO_LIBS)
+QCAIRO_LIBDIR=`pkg-config --variable=libdir qcairo`
+AC_SUBST(QCAIRO_LIBDIR)
+SPICE_REQUIRES+=" qcairo >= 1.4.6"
+
+PKG_CHECK_MODULES(CELT051, celt051 >= 0.5.1.1)
+AC_SUBST(CELT051_CFLAGS)
+AC_SUBST(CELT051_LIBS)
+AC_SUBST(CELT051_LIBDIR)
+SPICE_REQUIRES+=" celt051 >= 0.5.1.1"
+
+PKG_CHECK_MODULES(FFMPEG, libavcodec libavutil)
+AC_SUBST(FFMPEG_CFLAGS)
+AC_SUBST(FFMPEG_LIBS)
+FFMPEG_LIBDIR=`pkg-config --variable=libdir libavutil`
+AC_SUBST(FFMPEG_LIBDIR)
+SPICE_REQUIRES+=" libavcodec libavutil"
+
+PKG_CHECK_MODULES(ALSA, alsa)
+AC_SUBST(ALSA_CFLAGS)
+AC_SUBST(ALSA_LIBS)
+SPICE_REQUIRES+=" alsa"
+
+PKG_CHECK_MODULES(SSL, openssl)
+AC_SUBST(SSL_CFLAGS)
+AC_SUBST(SSL_LIBS)
+SPICE_REQUIRES+=" openssl"
+
+# These are commented out because the gl libraries on RHEL 5 do not have pkgconfig files
+#
+# PKG_CHECK_MODULES(GL, gl glu)
+# AC_SUBST(GL_CFLAGS)
+# AC_SUBST(GL_LIBS)
+# SPICE_REQUIRES+=" gl glu"
+
+have_gl=yes
+AC_CHECK_LIB(GL, glBlendFunc, GL_LIBS="$GL_LIBS -lGL", have_gl=no)
+AC_CHECK_LIB(GLU, gluSphere, GL_LIBS="$GL_LIBS -lGLU", have_gl=no)
+
+if test "x$have_gl" = "xno"; then
+   AC_MSG_ERROR([GL libraries not available])
+fi
+
+AC_SUBST(GL_LIBS)
+SPICE_NONPKGCONFIG_LIBS+=" $GL_LIBS"
+
+PKG_CHECK_MODULES(XRANDR, xrandr)
+AC_SUBST(XRANDR_CFLAGS)
+AC_SUBST(XRANDR_LIBS)
+SPICE_REQUIRES+=" xrandr"
+
+PKG_CHECK_MODULES(XRANDR12,
+        xrandr >= 1.2,
+        have_xrandr12=yes,
+        have_xrandr12=no)
+
+AM_CONDITIONAL([HAVE_XRANDR12], [test "x$have_xrandr12" = "xyes"])
+if test "x$have_xrandr12" = "xyes" ; then
+  AC_DEFINE([HAVE_XRANDR12], [], [Define if we have XRANDR 12])
+fi
+
+# Add parameter for (partial) static linkage of spice client.
+# this is used to achive single binary package for all (?) distros.
+AC_ARG_ENABLE(static-linkage, 
+	[  --enable-static-linkage will generate spice client binary with static linkage to external libraries ],
+	[SPICEC_STATIC_LINKAGE_BSTATIC=["-Wl,-Bstatic"];
+	SPICEC_STATIC_LINKAGE_BDYNAMIC=["-Wl,-Bdynamic"]])
+
+
+AS_IF([test "$_cflags_is_set" = "yes"], [], [
+    CFLAGS="-g -O3"
+])
+
+
+AS_IF([test "$_cxxflags_is_set" = "yes"], [], [
+    CXXFLAGS="-g -O3"
+])
+
+
+dnl ===========================================================================
+dnl check compiler flags
+
+AC_DEFUN([SPICE_CC_TRY_FLAG], [
+  AC_MSG_CHECKING([whether $CC supports $1])
+
+  spice_save_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS $1"
+
+  AC_COMPILE_IFELSE([ ], [spice_cc_flag=yes], [spice_cc_flag=no])
+  CFLAGS="$spice_save_CFLAGS"
+
+  if test "x$spice_cc_flag" = "xyes"; then
+    ifelse([$2], , :, [$2])
+  else
+    ifelse([$3], , :, [$3])
+  fi
+  AC_MSG_RESULT([$spice_cc_flag])
+])
+
+
+dnl Use lots of warning flags with with gcc and compatible compilers
+
+dnl Note: if you change the following variable, the cache is automatically
+dnl skipped and all flags rechecked.  So there's no need to do anything
+dnl else.  If for any reason you need to force a recheck, just change
+dnl MAYBE_WARN in an ignorable way (like adding whitespace)
+
+dnl MAYBE_WARN="-Wall -Wno-sign-compare -Werror -Wno-deprecated-declarations"
+
+MAYBE_WARN="-Wall -Wno-sign-compare -Werror -Wno-deprecated-declarations"
+
+
+# invalidate cached value if MAYBE_WARN has changed
+if test "x$spice_cv_warn_maybe" != "x$MAYBE_WARN"; then
+	unset spice_cv_warn_cflags
+fi
+AC_CACHE_CHECK([for supported warning flags], spice_cv_warn_cflags, [
+	echo
+	WARN_CFLAGS=""
+
+	# Some warning options are not supported by all versions of
+	# gcc, so test all desired options against the current
+	# compiler.
+	#
+	# Note that there are some order dependencies
+	# here. Specifically, an option that disables a warning will
+	# have no net effect if a later option then enables that
+	# warnings, (perhaps implicitly). So we put some grouped
+	# options (-Wall and -Wextra) up front and the -Wno options
+	# last.
+
+	for W in $MAYBE_WARN; do
+		SPICE_CC_TRY_FLAG([$W], [WARN_CFLAGS="$WARN_CFLAGS $W"])
+	done
+
+	spice_cv_warn_cflags=$WARN_CFLAGS
+	spice_cv_warn_maybe=$MAYBE_WARN
+
+	AC_MSG_CHECKING([which warning flags were supported])])
+WARN_CFLAGS="$spice_cv_warn_cflags"
+SPICE_CFLAGS="$SPICE_CFLAGS $WARN_CFLAGS"
+
+# We only wish to enable attribute(warn_unused_result) if we can prevent
+# gcc from generating thousands of warnings about the misapplication of the
+# attribute to void functions and variables.
+AC_MSG_CHECKING([how to enable unused result warnings])
+warn_unused_result=""
+if echo $WARN_CFLAGS | grep -e '-Wno-attributes' >/dev/null; then
+    AC_TRY_COMPILE([__attribute__((__warn_unused_result__))
+	int f (int i) { return i; }], [],
+	[warn_unused_result="__attribute__((__warn_unused_result__))"])
+fi
+AC_DEFINE_UNQUOTED([WARN_UNUSED_RESULT], [$warn_unused_result],
+	  [Define to the value your compiler uses to support the warn-unused-result attribute])
+AC_MSG_RESULT([$warn_unused_result])
+
+AC_SUBST(WARN_CFLAGS)
+AC_SUBST(CFLAGS_CFLAGS)
+
+dnl =========================================================================
+dnl -fvisibility stuff
+
+have_gcc4=no
+AC_MSG_CHECKING(for -fvisibility)
+AC_COMPILE_IFELSE([
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#else
+error Need GCC 4.0 for visibility
+#endif
+int main () { return 0; }
+], have_gcc4=yes)
+
+if test "x$have_gcc4" = "xyes"; then
+   VISIBILITY_HIDDEN_CFLAGS="-fvisibility=hidden"
+fi
+AC_MSG_RESULT($have_gcc4)
+AC_SUBST(VISIBILITY_HIDDEN_CFLAGS)
+
+
+AC_SUBST(SPICE_REQUIRES)
+AC_SUBST(SPICE_NONPKGCONFIG_CFLAGS)
+AC_SUBST(SPICE_NONPKGCONFIG_LIBS)
+
+AC_SUBST([SPICEC_STATIC_LINKAGE_BSTATIC])
+AC_SUBST([SPICEC_STATIC_LINKAGE_BDYNAMIC])
+
+AC_OUTPUT([
+Makefile
+spice.pc
+common/Makefile
+server/Makefile
+client/Makefile
+client/x11/Makefile
+client/x11/images/Makefile
+])
+
+dnl ==========================================================================
+echo "
+
+        Spice $VERSION
+        ==============
+
+        prefix:                   ${prefix}
+        c compiler:               ${CC}
+        c++ compiler:	          ${CXX}
+     
+        Have XRANDR 1.2:          ${have_xrandr12}
+
+        Red target:               ${red_target}
+
+        Now type 'make' to build $PACKAGE
+"
diff --git a/server/.gitignore b/server/.gitignore
new file mode 100644
index 00000000..07491dd4
--- /dev/null
+++ b/server/.gitignore
@@ -0,0 +1,8 @@
+*.la
+*.lo
+*.loT
+*.o
+.deps
+.libs
+Makefile
+Makefile.in
diff --git a/server/Makefile.am b/server/Makefile.am
new file mode 100644
index 00000000..e6ffab40
--- /dev/null
+++ b/server/Makefile.am
@@ -0,0 +1,81 @@
+NULL =
+
+INCLUDES = \
+	-I. 					\
+	-I$(top_srcdir)/common			\
+	$(FFMPEG_CFLAGS)			\
+	$(QCAIRO_CFLAGS)			\
+	$(GL_CFLAGS)				\
+	$(LOG4CPP_CFLAGS)			\
+	$(SSL_CFLAGS)				\
+	$(CELT051_CFLAGS)			\
+	-DCAIRO_CANVAS_IMAGE_CACHE		\
+	-DRED_STATISTICS			\
+	$(WARN_CFLAGS)                          \
+	$(VISIBILITY_HIDDEN_CFLAGS)		\
+	$(NULL)
+
+COMMON_SRCS = 						\
+	$(top_srcdir)/common/cairo_canvas.c		\
+	$(top_srcdir)/common/gl_canvas.c		\
+	$(top_srcdir)/common/region.c			\
+	$(top_srcdir)/common/glc.c			\
+	$(top_srcdir)/common/ogl_ctx.c			\
+	$(top_srcdir)/common/rop3.c			\
+	$(top_srcdir)/common/quic.c			\
+	$(top_srcdir)/common/lz.c			\
+	$(top_srcdir)/common/canvas_utils.c		\
+	$(NULL)
+
+lib_LTLIBRARIES = libspice.la
+
+libspice_la_LDFLAGS = 				\
+	-version-number $(SPICE_LT_VERSION)	\
+	-no-undefined				\
+	$(NULL)
+
+libspice_la_LIBADD = 				\
+	$(GL_LIBS)				\
+	$(FFMPEG_LIBS)				\
+	$(QCAIRO_LIBS)				\
+	$(SSL_LIBS)				\
+	$(CELT051_LIBS)				\
+	$(LIBRT)				\
+	$(NULL)
+
+libspice_la_SOURCES =				\
+	glz_encoder.c				\
+	glz_encoder_config.h			\
+	glz_encoder_dictionary.c		\
+	glz_encoder_dictionary.h		\
+	glz_encoder_dictionary_protected.h	\
+	glz_encoder.h				\
+	red_bitmap_utils.h			\
+	red_client_cache.h			\
+	red_client_shared_cache.h		\
+	red_common.h				\
+	red_dispatcher.c			\
+	red_dispatcher.h			\
+	reds.c					\
+	reds.h					\
+	stat.h					\
+	red_worker.c				\
+	red_worker.h				\
+	red_yuv.h				\
+	snd_worker.c				\
+	snd_worker.h				\
+	spice.h					\
+	vd_interface.h				\
+	$(COMMON_SRCS)				\
+	$(NULL)
+
+libspiceincludedir = $(includedir)/libspice
+libspiceinclude_HEADERS =               	\
+	spice.h					\
+	vd_interface.h				\
+	$(NULL)
+
+EXTRA_DIST =					\
+	glz_encode_match_tmpl.c			\
+	glz_encode_tmpl.c			\
+	$(NULL)
diff --git a/server/glz_encode_match_tmpl.c b/server/glz_encode_match_tmpl.c
new file mode 100644
index 00000000..01427173
--- /dev/null
+++ b/server/glz_encode_match_tmpl.c
@@ -0,0 +1,151 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define SHORT_PIX_IMAGE_DIST_LEVEL_1 64 //(1 << 6)
+#define SHORT_PIX_IMAGE_DIST_LEVEL_2 16384 // (1 << 14)
+#define SHORT_PIX_IMAGE_DIST_LEVEL_3 4194304 // (1 << 22)
+#define FAR_PIX_IMAGE_DIST_LEVEL_1 256 // (1 << 8)
+#define FAR_PIX_IMAGE_DIST_LEVEL_2 65536 // (1 << 16)
+#define FAR_PIX_IMAGE_DIST_LEVEL_3 16777216 // (1 << 24)
+
+/* if image_distance = 0, pixel_distance is the distance between the matching pixels.
+  Otherwise, it is the offset from the beginning of the referred image */
+#if defined(GLZ_ENCODE_MATCH) /* actually perfroming the encoding */
+static INLINE void encode_match(Encoder *encoder, uint32_t image_distance,
+                                size_t pixel_distance, size_t len)
+#elif defined(GLZ_ENCODE_SIZE) /* compute the size of the encoding except for the match length*/
+static INLINE int get_encode_ref_size(uint32_t image_distance, size_t pixel_distance)
+#endif
+{
+#if defined(GLZ_ENCODE_SIZE)
+    int encode_size;
+#endif
+
+#if defined(GLZ_ENCODE_MATCH)
+    /* encoding the match length + Long/Short dist bit +  12 LSB pixels of pixel_distance*/
+    if (len < 7) {
+        if (pixel_distance < MAX_PIXEL_SHORT_DISTANCE) {
+            encode(encoder, (uint8_t)((len << 5) + (pixel_distance & 0x0f)));
+        } else {
+            encode(encoder, (uint8_t)((len << 5) + 16 + (pixel_distance & 0x0f)));
+        }
+        encode(encoder, (uint8_t)((pixel_distance >> 4) & 255));
+    } else {
+        if (pixel_distance < MAX_PIXEL_SHORT_DISTANCE) {
+            encode(encoder, (uint8_t)((7 << 5) + (pixel_distance & 0x0f)));
+        } else {
+            encode(encoder, (uint8_t)((7 << 5) + 16 + (pixel_distance & 0x0f)));
+        }
+        for (len -= 7; len >= 255; len -= 255) {
+            encode(encoder, 255);
+        }
+        encode(encoder, (uint8_t)len);
+        encode(encoder, (uint8_t)((pixel_distance >> 4) & 255));
+    }
+#endif
+
+
+    /* encoding the rest of the pixel ditsance and the image_dist and its 2 control bits */
+
+    /* The first 2 MSB bits indicate how many more bytes should be read for image dist */
+    if (pixel_distance < MAX_PIXEL_SHORT_DISTANCE) {
+        if (image_distance < SHORT_PIX_IMAGE_DIST_LEVEL_1) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)(image_distance & 0x3f));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 3;
+#endif
+        } else if (image_distance < SHORT_PIX_IMAGE_DIST_LEVEL_2) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)((1 << 6) + (image_distance & 0x3f)));
+            encode(encoder, (uint8_t)((image_distance >> 6) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 4;
+#endif
+        } else if (image_distance < SHORT_PIX_IMAGE_DIST_LEVEL_3) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)((1 << 7) + (image_distance & 0x3f)));
+            encode(encoder, (uint8_t)((image_distance >> 6) & 255));
+            encode(encoder, (uint8_t)((image_distance >> 14) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 5;
+#endif
+        } else {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)((1 << 7) + (1 << 6) + (image_distance & 0x3f)));
+            encode(encoder, (uint8_t)((image_distance >> 6) & 255));
+            encode(encoder, (uint8_t)((image_distance >> 14) & 255));
+            encode(encoder, (uint8_t)((image_distance >> 22) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 6;
+#endif
+        }
+    } else {
+        /* the third MSB bit indicates if the pixel_distance is medium/long*/
+        uint8_t long_dist_control = (pixel_distance < MAX_PIXEL_MEDIUM_DISTANCE) ? 0 : 32;
+        if (image_distance == 0) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)(long_dist_control + ((pixel_distance >> 12) & 31)));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 3;
+#endif
+        } else if (image_distance < FAR_PIX_IMAGE_DIST_LEVEL_1) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder,
+                   (uint8_t)(long_dist_control + (1 << 6) + ((pixel_distance >> 12) & 31)));
+            encode(encoder, (uint8_t)(image_distance & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 4;
+#endif
+        } else if (image_distance < FAR_PIX_IMAGE_DIST_LEVEL_2) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder,
+                   (uint8_t)(long_dist_control + (1 << 7) + ((pixel_distance >> 12) & 31)));
+            encode(encoder, (uint8_t)(image_distance & 255));
+            encode(encoder, (uint8_t)((image_distance >> 8) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 5;
+#endif
+        } else {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder,
+                   (uint8_t)(long_dist_control + (1 << 7) + (1 << 6) +
+                                                                    ((pixel_distance >> 12) & 31)));
+            encode(encoder, (uint8_t)(image_distance & 255));
+            encode(encoder, (uint8_t)((image_distance >> 8) & 255));
+            encode(encoder, (uint8_t)((image_distance >> 16) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size = 6;
+#endif
+        }
+
+        if (long_dist_control) {
+#if defined(GLZ_ENCODE_MATCH)
+            encode(encoder, (uint8_t)((pixel_distance >> 17) & 255));
+#elif defined(GLZ_ENCODE_SIZE)
+            encode_size++;
+#endif
+        }
+    }
+
+#if defined(GLZ_ENCODE_SIZE)
+    return encode_size;
+#endif
+}
+
+#undef GLZ_ENCODE_SIZE
+#undef GLZ_ENCODE_MATCH
diff --git a/server/glz_encode_tmpl.c b/server/glz_encode_tmpl.c
new file mode 100644
index 00000000..32b68fea
--- /dev/null
+++ b/server/glz_encode_tmpl.c
@@ -0,0 +1,572 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define DJB2_START 5381;
+#define DJB2_HASH(hash, c) (hash = ((hash << 5) + hash) ^ (c)) //|{hash = ((hash << 5) + hash) + c;}
+
+/*
+    For each pixel type the following macros are defined:
+    PIXEL                         : input type
+    FNAME(name)
+    ENCODE_PIXEL(encoder, pixel) : writing a pixel to the compressed buffer (byte by byte)
+    SAME_PIXEL(pix1, pix2)         : comparing two pixels
+    HASH_FUNC(value, pix_ptr)    : hash func of 3 consecutive pixels
+*/
+
+#ifdef LZ_PLT
+#define PIXEL one_byte_pixel_t
+#define FNAME(name) glz_plt_##name
+#define ENCODE_PIXEL(e, pix) encode(e, (pix).a)   // gets the pixel and write only the needed bytes
+                                                  // from the pixel
+#define SAME_PIXEL(pix1, pix2) ((pix1).a == (pix2).a)
+#define MIN_REF_ENCODE_SIZE 4
+#define MAX_REF_ENCODE_SIZE 7
+#define HASH_FUNC(v, p) {  \
+    v = DJB2_START;        \
+    DJB2_HASH(v, p[0].a);  \
+    DJB2_HASH(v, p[1].a);  \
+    DJB2_HASH(v, p[2].a);  \
+    v &= HASH_MASK;        \
+    }
+#endif
+
+#ifdef LZ_RGB_ALPHA
+//#undef LZ_RGB_ALPHA
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb_alpha_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).pad);}
+#define SAME_PIXEL(pix1, pix2) ((pix1).pad == (pix2).pad)
+#define MIN_REF_ENCODE_SIZE 4
+#define MAX_REF_ENCODE_SIZE 7
+#define HASH_FUNC(v, p) {    \
+    v = DJB2_START;          \
+    DJB2_HASH(v, p[0].pad);  \
+    DJB2_HASH(v, p[1].pad);  \
+    DJB2_HASH(v, p[2].pad);  \
+    v &= HASH_MASK;          \
+    }
+#endif
+
+
+#ifdef LZ_RGB16
+#define PIXEL rgb16_pixel_t
+#define FNAME(name) glz_rgb16_##name
+#define GET_r(pix) (((pix) >> 10) & 0x1f)
+#define GET_g(pix) (((pix) >> 5) & 0x1f)
+#define GET_b(pix) ((pix) & 0x1f)
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix) >> 8); encode(e, (pix) & 0xff);}
+#define MIN_REF_ENCODE_SIZE 2
+#define MAX_REF_ENCODE_SIZE 3
+#define HASH_FUNC(v, p) {                  \
+    v = DJB2_START;                        \
+    DJB2_HASH(v, p[0] & (0x00ff));         \
+    DJB2_HASH(v, (p[0] >> 8) & (0x007f));  \
+    DJB2_HASH(v, p[1] & (0x00ff));         \
+    DJB2_HASH(v, (p[1] >> 8) & (0x007f));  \
+    DJB2_HASH(v, p[2] & (0x00ff));         \
+    DJB2_HASH(v, (p[2] >> 8) & (0x007f));  \
+    v &= HASH_MASK;                        \
+}
+#endif
+
+#ifdef LZ_RGB24
+#define PIXEL rgb24_pixel_t
+#define FNAME(name) glz_rgb24_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
+#define MIN_REF_ENCODE_SIZE 2
+#define MAX_REF_ENCODE_SIZE 2
+#endif
+
+#ifdef LZ_RGB32
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) glz_rgb32_##name
+#define ENCODE_PIXEL(e, pix) {encode(e, (pix).b); encode(e, (pix).g); encode(e, (pix).r);}
+#define MIN_REF_ENCODE_SIZE 2
+#define MAX_REF_ENCODE_SIZE 2
+#endif
+
+
+#if  defined(LZ_RGB24) || defined(LZ_RGB32)
+#define GET_r(pix) ((pix).r)
+#define GET_g(pix) ((pix).g)
+#define GET_b(pix) ((pix).b)
+#define HASH_FUNC(v, p) {    \
+    v = DJB2_START;          \
+    DJB2_HASH(v, p[0].r);    \
+    DJB2_HASH(v, p[0].g);    \
+    DJB2_HASH(v, p[0].b);    \
+    DJB2_HASH(v, p[1].r);    \
+    DJB2_HASH(v, p[1].g);    \
+    DJB2_HASH(v, p[1].b);    \
+    DJB2_HASH(v, p[2].r);    \
+    DJB2_HASH(v, p[2].g);    \
+    DJB2_HASH(v, p[2].b);    \
+    v &= HASH_MASK;          \
+    }
+#endif
+
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+#define SAME_PIXEL(p1, p2) (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) && \
+                            GET_b(p1) == GET_b(p2))
+
+#endif
+
+#ifndef LZ_PLT
+#define PIXEL_ID(pix_ptr, seg_ptr) \
+    ((pix_ptr) - ((PIXEL *)(seg_ptr)->lines) + (seg_ptr)->pixels_so_far)
+#define PIXEL_DIST(src_pix_ptr, src_seg_ptr, ref_pix_ptr, ref_seg_ptr) \
+    (PIXEL_ID(src_pix_ptr,src_seg_ptr) - PIXEL_ID(ref_pix_ptr, ref_seg_ptr))
+#else
+#define PIXEL_ID(pix_ptr, seg_ptr, pix_per_byte) \
+    (((pix_ptr) - ((PIXEL *)(seg_ptr)->lines)) * pix_per_byte + (seg_ptr)->pixels_so_far)
+#define PIXEL_DIST(src_pix_ptr, src_seg_ptr, ref_pix_ptr, ref_seg_ptr, pix_per_byte) \
+    ((PIXEL_ID(src_pix_ptr,src_seg_ptr, pix_per_byte) - \
+    PIXEL_ID(ref_pix_ptr, ref_seg_ptr, pix_per_byte)) / pix_per_byte)
+#endif
+
+/* returns the length of the match. 0 if no match.
+  if image_distance = 0, pixel_distance is the distance between the matching pixels.
+  Otherwise, it is the offset from the beginning of the referred image */
+static INLINE size_t FNAME(do_match)(SharedDictionary *dict, 
+                                     WindowImageSegment *ref_seg, const PIXEL *ref, 
+                                     const PIXEL *ref_limit,
+                                     WindowImageSegment *ip_seg,  const PIXEL *ip, 
+                                     const PIXEL *ip_limit,
+#ifdef  LZ_PLT
+                                     int pix_per_byte,
+#endif
+                                     size_t *o_image_dist, size_t *o_pix_distance)
+{
+    int encode_size;
+    const PIXEL *tmp_ip = ip;
+    const PIXEL *tmp_ref = ref;
+
+    if (ref > (ref_limit - MIN_REF_ENCODE_SIZE)) {
+        return 0; // in case the hash entry is not relvant
+    }
+
+
+    /* min match lenght == MIN_REF_ENCODE_SIZE (depends on pixel type) */
+
+    if (!SAME_PIXEL(*tmp_ref, *tmp_ip)) {
+        return 0;
+    } else {
+        tmp_ref++;
+        tmp_ip++;
+    }
+
+
+    if (!SAME_PIXEL(*tmp_ref, *tmp_ip)) {
+        return 0;
+    } else {
+        tmp_ref++;
+        tmp_ip++;
+    }
+
+#if defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+    if (!SAME_PIXEL(*tmp_ref, *tmp_ip)) {
+        return 0;
+    } else {
+        tmp_ref++;
+        tmp_ip++;
+    }
+
+
+    if (!SAME_PIXEL(*tmp_ref, *tmp_ip)) {
+        return 0;
+    } else {
+        tmp_ref++;
+        tmp_ip++;
+    }
+
+#endif
+
+
+    *o_image_dist = ip_seg->image->id - ref_seg->image->id;
+
+    if (!(*o_image_dist)) { // the ref is inside the same image - encode distance
+#ifndef LZ_PLT
+        *o_pix_distance = PIXEL_DIST(ip, ip_seg, ref, ref_seg);
+#else
+        // in bytes
+        *o_pix_distance = PIXEL_DIST(ip, ip_seg, ref, ref_seg, pix_per_byte);
+#endif
+    } else { // the ref is at different image - encode offset from the image start
+#ifndef LZ_PLT
+        *o_pix_distance = PIXEL_DIST(ref, ref_seg,
+                                     (PIXEL *)(dict->window.segs[ref_seg->image->first_seg].lines),
+                                     &dict->window.segs[ref_seg->image->first_seg]
+                                     );
+#else
+        // in bytes
+        *o_pix_distance = PIXEL_DIST(ref, ref_seg,
+                                     (PIXEL *)(dict->window.segs[ref_seg->image->first_seg].lines),
+                                     &dict->window.segs[ref_seg->image->first_seg],
+                                     pix_per_byte);
+#endif
+    }
+
+    if ((*o_pix_distance == 0) || (*o_pix_distance >= MAX_PIXEL_LONG_DISTANCE) ||
+        (*o_image_dist > MAX_IMAGE_DIST)) {
+        return 0;
+    }
+
+
+    /* continue the match*/
+    while ((tmp_ip < ip_limit) && (tmp_ref < ref_limit)) {
+        if (!SAME_PIXEL(*tmp_ref, *tmp_ip)) {
+            break;
+        } else {
+            tmp_ref++;
+            tmp_ip++;
+        }
+    }
+
+
+    if ((tmp_ip - ip) > MAX_REF_ENCODE_SIZE) {
+        return (tmp_ip - ip);
+    }
+
+    encode_size = get_encode_ref_size(*o_image_dist, *o_pix_distance);
+
+    // min number of identical pixels for a match
+#if defined(LZ_RGB16)
+    encode_size /= 2;
+#elif defined(LZ_RGB24) || defined(LZ_RGB32)
+    encode_size /= 3;
+#endif
+
+    encode_size++; // the minimum match
+    // match len is smaller than the encoding - not worth encoding
+    if ((tmp_ip - ip) < encode_size) {
+        return 0;
+    }
+    return (tmp_ip - ip);
+}
+
+/* compresses one segment starting from 'from'.
+   In order to encode a match, we use pixels resolution when we encode RGB image,
+   and bytes count when we encode PLT.
+*/
+static void FNAME(compress_seg)(Encoder *encoder, uint32_t seg_idx, PIXEL *from, int copied)
+{
+    WindowImageSegment *seg = &encoder->dict->window.segs[seg_idx];
+    const PIXEL *ip = from;
+    const PIXEL *ip_bound = (PIXEL *)(seg->lines_end) - BOUND_OFFSET;
+    const PIXEL *ip_limit = (PIXEL *)(seg->lines_end) - LIMIT_OFFSET;
+    int hval;
+    int copy = copied;
+#ifdef  LZ_PLT
+    int pix_per_byte = PLT_PIXELS_PER_BYTE[encoder->cur_image.type];
+#endif
+
+#ifdef DEBUG_ENCODE
+    int n_encoded = 0;
+#endif
+
+    if (copy == 0) {
+        encode_copy_count(encoder, MAX_COPY - 1);
+    }
+
+
+    while (LZ_EXPECT_CONDITIONAL(ip < ip_limit)) {
+        const PIXEL            *ref;
+        const PIXEL            *ref_limit;
+        WindowImageSegment     *ref_seg;
+        uint32_t ref_seg_idx;
+        size_t pix_dist;
+        size_t image_dist;
+        /* minimum match length */
+        size_t len = 0;
+
+        /* comparison starting-point */
+        const PIXEL            *anchor = ip;
+#ifdef CHAINED_HASH
+        int hash_id = 0;
+        size_t best_len = 0;
+        size_t best_pix_dist = 0;
+        size_t best_image_dist = 0;
+#endif
+
+        /* check for a run */
+
+        if (LZ_EXPECT_CONDITIONAL(ip > (PIXEL *)(seg->lines))) {
+            if (SAME_PIXEL(ip[-1], ip[0]) && SAME_PIXEL(ip[0], ip[1]) && SAME_PIXEL(ip[1], ip[2])) {
+                PIXEL x;
+                pix_dist = 1;
+                image_dist = 0;
+
+                ip += 3;
+                ref = anchor + 2;
+                ref_limit = (PIXEL *)(seg->lines_end);
+                len = 3;
+
+                x = *ref;
+
+                while (ip < ip_bound) { // TODO: maybe separate a run from the same seg or from
+                                       // different ones in order to spare ref < ref_limit
+                    if (!SAME_PIXEL(*ip, x)) {
+                        ip++;
+                        break;
+                    } else {
+                        ip++;
+                        len++;
+                    }
+                }
+
+                goto match;
+            } // END RLE MATCH
+        }
+
+        /* find potential match */
+        HASH_FUNC(hval, ip);
+
+#ifdef CHAINED_HASH
+        for (hash_id = 0; hash_id < HASH_CHAIN_SIZE; hash_id++) {
+            ref_seg_idx = encoder->dict->htab[hval][hash_id].image_seg_idx;
+#else
+        ref_seg_idx = encoder->dict->htab[hval].image_seg_idx;
+#endif
+            ref_seg = encoder->dict->window.segs + ref_seg_idx;
+            if (REF_SEG_IS_VALID(encoder->dict, encoder->id,
+                                 ref_seg, seg)) {
+#ifdef CHAINED_HASH
+                ref = ((PIXEL *)ref_seg->lines) + encoder->dict->htab[hval][hash_id].ref_pix_idx;
+#else
+                ref = ((PIXEL *)ref_seg->lines) + encoder->dict->htab[hval].ref_pix_idx;
+#endif
+                ref_limit = (PIXEL *)ref_seg->lines_end;
+
+                len = FNAME(do_match)(encoder->dict, ref_seg, ref, ref_limit, seg, ip, ip_bound,
+#ifdef  LZ_PLT
+                                      pix_per_byte,
+#endif
+                                      &image_dist, &pix_dist);
+
+#ifdef CHAINED_HASH
+                // TODO. not compare len but rather len - encode_size
+                if (len > best_len) {
+                    best_len = len;
+                    best_pix_dist = pix_dist;
+                    best_image_dist = image_dist;
+                }
+#endif
+            }
+
+#ifdef CHAINED_HASH
+        } // end chain loop
+        len = best_len;
+        pix_dist = best_pix_dist;
+        image_dist = best_image_dist;
+#endif
+
+        /* update hash table */
+        UPDATE_HASH(encoder->dict, hval, seg_idx, anchor - ((PIXEL *)seg->lines));
+
+        if (!len) {
+            goto literal;
+        }
+
+match:        // RLE or dictionary (both are encoded by distance from ref (-1) and length)
+#ifdef DEBUG_ENCODE
+        printf(", match(%d, %d, %d)", image_dist, pix_dist, len);
+        n_encoded += len;
+#endif
+
+        /* distance is biased */
+        if (!image_dist) {
+            pix_dist--;
+        }
+
+        /* if we have copied something, adjust the copy count */
+        if (copy) {
+            /* copy is biased, '0' means 1 byte copy */
+            update_copy_count(encoder, copy - 1);
+        } else {
+            /* back, to overwrite the copy count */
+            compress_output_prev(encoder);
+        }
+
+        /* reset literal counter */
+        copy = 0;
+
+        /* length is biased, '1' means a match of 3 pixels for PLT and alpha*/
+        /* for RGB 16 1 means 2 */
+        /* for RGB24/32 1 means 1...*/
+        ip = anchor + len - 2;
+
+#if defined(LZ_RGB16)
+        len--;
+#elif defined(LZ_PLT) || defined(LZ_RGB_ALPHA)
+        len -= 2;
+#endif
+        GLZ_ASSERT(encoder->usr, len > 0);
+        encode_match(encoder, image_dist, pix_dist, len);
+
+        /* update the hash at match boundary */
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+        if (ip > anchor) {
+#endif
+            HASH_FUNC(hval, ip);
+            UPDATE_HASH(encoder->dict, hval, seg_idx, ip - ((PIXEL *)seg->lines));
+            ip++;
+#if defined(LZ_RGB16) || defined(LZ_RGB24) || defined(LZ_RGB32)
+        } else {ip++;
+        }
+#endif
+#if defined(LZ_RGB24) || defined(LZ_RGB32)
+        if (ip > anchor) {
+#endif
+            HASH_FUNC(hval, ip);
+            UPDATE_HASH(encoder->dict, hval, seg_idx, ip - ((PIXEL *)seg->lines));
+            ip++;
+#if defined(LZ_RGB24) || defined(LZ_RGB32)
+        } else {
+            ip++;
+        }
+#endif
+        /* assuming literal copy */
+        encode_copy_count(encoder, MAX_COPY - 1);
+        continue;
+
+literal:
+#ifdef DEBUG_ENCODE
+        printf(", copy");
+        n_encoded++;
+#endif
+        ENCODE_PIXEL(encoder, *anchor);
+        anchor++;
+        ip = anchor;
+        copy++;
+
+        if (LZ_UNEXPECT_CONDITIONAL(copy == MAX_COPY)) {
+            copy = 0;
+            encode_copy_count(encoder, MAX_COPY - 1);
+        }
+    } // END LOOP (ip < ip_limit)
+
+
+    /* left-over as literal copy */
+    ip_bound++;
+    while (ip <= ip_bound) {
+#ifdef DEBUG_ENCODE
+        printf(", copy");
+        n_encoded++;
+#endif
+        ENCODE_PIXEL(encoder, *ip);
+        ip++;
+        copy++;
+        if (copy == MAX_COPY) {
+            copy = 0;
+            encode_copy_count(encoder, MAX_COPY - 1);
+        }
+    }
+
+    /* if we have copied something, adjust the copy length */
+    if (copy) {
+        update_copy_count(encoder, copy - 1);
+    } else {
+        compress_output_prev(encoder);
+    }
+#ifdef DEBUG_ENCODE
+    printf("\ntotal encoded=%d\n", n_encoded);
+#endif
+}
+
+
+/*  If the file is very small, copies it.
+    copies the first two pixels of the first segment, and sends the segments
+    one by one to compress_seg.
+    the number of bytes compressed are stored inside encoder. */
+static void FNAME(compress)(Encoder *encoder)
+{
+    uint32_t seg_id = encoder->cur_image.first_win_seg;
+    PIXEL    *ip;
+    SharedDictionary *dict = encoder->dict;
+    int hval;
+
+    // fetch the first image segment that is not too small
+    while ((seg_id != NULL_IMAGE_SEG_ID) &&
+           (dict->window.segs[seg_id].image->id == encoder->cur_image.id) &&
+           ((((PIXEL *)dict->window.segs[seg_id].lines_end) -
+             ((PIXEL *)dict->window.segs[seg_id].lines)) < 4)) {
+        // coping the segment
+        if (dict->window.segs[seg_id].lines != dict->window.segs[seg_id].lines_end) {
+            ip = (PIXEL *)dict->window.segs[seg_id].lines;
+            // Note: we assume MAX_COPY > 3
+            encode_copy_count(encoder, (uint8_t)(
+                                  (((PIXEL *)dict->window.segs[seg_id].lines_end) -
+                                   ((PIXEL *)dict->window.segs[seg_id].lines)) - 1));
+            while (ip < (PIXEL *)dict->window.segs[seg_id].lines_end) {
+                ENCODE_PIXEL(encoder, *ip);
+                ip++;
+            }
+        }
+        seg_id = dict->window.segs[seg_id].next;
+    }
+
+    if ((seg_id == NULL_IMAGE_SEG_ID) ||
+        (dict->window.segs[seg_id].image->id != encoder->cur_image.id)) {
+        return;
+    }
+
+    ip = (PIXEL *)dict->window.segs[seg_id].lines;
+
+
+    encode_copy_count(encoder, MAX_COPY - 1);
+
+    HASH_FUNC(hval, ip);
+    UPDATE_HASH(encoder->dict, hval, seg_id, 0);
+
+    ENCODE_PIXEL(encoder, *ip);
+    ip++;
+    ENCODE_PIXEL(encoder, *ip);
+    ip++;
+#ifdef DEBUG_ENCODE
+    printf("copy, copy");
+#endif
+    // compressing the first segment
+    FNAME(compress_seg)(encoder, seg_id, ip, 2);
+
+    // compressing the next segments
+    for (seg_id = dict->window.segs[seg_id].next; 
+        seg_id != NULL_IMAGE_SEG_ID && (
+        dict->window.segs[seg_id].image->id == encoder->cur_image.id); 
+        seg_id = dict->window.segs[seg_id].next) {
+        FNAME(compress_seg)(encoder, seg_id, (PIXEL *)dict->window.segs[seg_id].lines, 0);
+    }
+}
+
+#undef FNAME
+#undef PIXEL_ID
+#undef PIXEL_DIST
+#undef PIXEL
+#undef ENCODE_PIXEL
+#undef SAME_PIXEL
+#undef HASH_FUNC
+#undef GET_r
+#undef GET_g
+#undef GET_b
+#undef GET_CODE
+#undef LZ_PLT
+#undef LZ_RGB_ALPHA
+#undef LZ_RGB16
+#undef LZ_RGB24
+#undef LZ_RGB32
+#undef MIN_REF_ENCODE_SIZE
+#undef MAX_REF_ENCODE_SIZE
+
diff --git a/server/glz_encoder.c b/server/glz_encoder.c
new file mode 100644
index 00000000..f0caf897
--- /dev/null
+++ b/server/glz_encoder.c
@@ -0,0 +1,308 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <pthread.h>
+#include <stdio.h>
+#include "glz_encoder.h"
+#include "glz_encoder_dictionary_protected.h"
+
+
+/* Holds a specific data for one encoder, and data that is relevant for the current image encoded */
+typedef struct Encoder {
+    GlzEncoderUsrContext *usr;
+    uint8_t id;
+    SharedDictionary     *dict;
+
+    struct {
+        LzImageType type;
+        uint32_t id;
+        uint32_t first_win_seg;
+    } cur_image;
+
+    struct {
+        uint8_t            *start;
+        uint8_t            *now;
+        uint8_t            *end;
+        size_t bytes_count;
+        uint8_t            *last_copy;  // pointer to the last byte in which copy count was written
+    } io;
+} Encoder;
+
+
+/**************************************************************************
+* Handling writing the encoded image to the output buffer
+***************************************************************************/
+static INLINE int more_io_bytes(Encoder *encoder)
+{
+    uint8_t *io_ptr;
+    int num_io_bytes = encoder->usr->more_space(encoder->usr, &io_ptr);
+    encoder->io.bytes_count += num_io_bytes;
+    encoder->io.now = io_ptr;
+    encoder->io.end = encoder->io.now + num_io_bytes;
+    return num_io_bytes;
+}
+
+static INLINE void encode(Encoder *encoder, uint8_t byte)
+{
+    if (encoder->io.now == encoder->io.end) {
+        if (more_io_bytes(encoder) <= 0) {
+            encoder->usr->error(encoder->usr, "%s: no more bytes\n", __FUNCTION__);
+        }
+        GLZ_ASSERT(encoder->usr, encoder->io.now);
+    }
+
+    GLZ_ASSERT(encoder->usr, encoder->io.now < encoder->io.end);
+    *(encoder->io.now++) = byte;
+}
+
+static INLINE void encode_32(Encoder *encoder, unsigned int word)
+{
+    encode(encoder, (uint8_t)(word >> 24));
+    encode(encoder, (uint8_t)(word >> 16) & 0x0000ff);
+    encode(encoder, (uint8_t)(word >> 8) & 0x0000ff);
+    encode(encoder, (uint8_t)(word & 0x0000ff));
+}
+
+static INLINE void encode_64(Encoder *encoder, uint64_t word)
+{
+    encode_32(encoder, (uint32_t)(word >> 32));
+    encode_32(encoder, (uint32_t)(word & 0xffffff));
+}
+
+static INLINE void encode_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+    encode(encoder, copy_count);
+    encoder->io.last_copy = encoder->io.now - 1; // io_now cannot be the first byte of the buffer
+}
+
+static INLINE void update_copy_count(Encoder *encoder, uint8_t copy_count)
+{
+    GLZ_ASSERT(encoder->usr, encoder->io.last_copy);
+    *(encoder->io.last_copy) = copy_count;
+}
+
+// decrease the io ptr by 1
+static INLINE void compress_output_prev(Encoder *encoder)
+{
+    // io_now cannot be the first byte of the buffer
+    encoder->io.now--;
+    // the function should be called only when copy count is written unnecessarily by glz_compress
+    GLZ_ASSERT(encoder->usr, encoder->io.now == encoder->io.last_copy)
+}
+
+static int encoder_reset(Encoder *encoder, uint8_t *io_ptr, uint8_t *io_ptr_end)
+{
+    GLZ_ASSERT(encoder->usr, io_ptr <= io_ptr_end);
+    encoder->io.bytes_count = io_ptr_end - io_ptr;
+    encoder->io.start = io_ptr;
+    encoder->io.now = io_ptr;
+    encoder->io.end = io_ptr_end;
+    encoder->io.last_copy = NULL;
+
+    return TRUE;
+}
+
+/**********************************************************
+*           Encoding
+***********************************************************/
+
+GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
+                                      GlzEncoderUsrContext *usr)
+{
+    Encoder *encoder;
+
+    if (!usr || !usr->error || !usr->warn || !usr->info || !usr->malloc ||
+        !usr->free || !usr->more_space) {
+        return NULL;
+    }
+
+    if (!(encoder = (Encoder *)usr->malloc(usr, sizeof(Encoder)))) {
+        return NULL;
+    }
+
+    encoder->id = id;
+    encoder->usr = usr;
+    encoder->dict = (SharedDictionary *)dictionary;
+
+    return (GlzEncoderContext *)encoder;
+}
+
+void glz_encoder_destroy(GlzEncoderContext *opaque_encoder)
+{
+    Encoder *encoder = (Encoder *)opaque_encoder;
+
+    if (!opaque_encoder) {
+        return;
+    }
+
+    encoder->usr->free(encoder->usr, encoder);
+}
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__GNUC__) && (__GNUC__ > 2)
+#define LZ_EXPECT_CONDITIONAL(c) (__builtin_expect((c), 1))
+#define LZ_UNEXPECT_CONDITIONAL(c) (__builtin_expect((c), 0))
+#else
+#define LZ_EXPECT_CONDITIONAL(c) (c)
+#define LZ_UNEXPECT_CONDITIONAL(c) (c)
+#endif
+
+
+typedef uint8_t BYTE;
+
+typedef struct __attribute__ ((__packed__)) one_byte_pixel_t {
+    BYTE a;
+} one_byte_pixel_t;
+
+typedef struct __attribute__ ((__packed__)) rgb32_pixel_t {
+    BYTE b;
+    BYTE g;
+    BYTE r;
+    BYTE pad;
+} rgb32_pixel_t;
+
+typedef struct __attribute__ ((__packed__)) rgb24_pixel_t {
+    BYTE b;
+    BYTE g;
+    BYTE r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#define BOUND_OFFSET 2
+#define LIMIT_OFFSET 6
+#define MIN_FILE_SIZE 4
+
+#define MAX_PIXEL_SHORT_DISTANCE 4096       // (1 << 12)
+#define MAX_PIXEL_MEDIUM_DISTANCE 131072    // (1 << 17)  2 ^ (12 + 5)
+#define MAX_PIXEL_LONG_DISTANCE 33554432    // (1 << 25)  2 ^ (12 + 5 + 8)
+#define MAX_IMAGE_DIST 16777215             // (1 << 24 - 1)
+
+
+//#define DEBUG_ENCODE
+
+
+#define GLZ_ENCODE_SIZE
+#include "glz_encode_match_tmpl.c"
+#define GLZ_ENCODE_MATCH
+#include "glz_encode_match_tmpl.c"
+
+#define LZ_PLT
+#include "glz_encode_tmpl.c"
+
+#define LZ_RGB16
+#include "glz_encode_tmpl.c"
+
+#define LZ_RGB24
+#include "glz_encode_tmpl.c"
+
+#define LZ_RGB32
+#include "glz_encode_tmpl.c"
+
+#define LZ_RGB_ALPHA
+#include "glz_encode_tmpl.c"
+
+
+int glz_encode(GlzEncoderContext *opaque_encoder,
+               LzImageType type, int width, int height, int top_down,
+               uint8_t *lines, unsigned int num_lines, int stride,
+               uint8_t *io_ptr, unsigned int num_io_bytes,
+               GlzUsrImageContext *usr_context, GlzEncDictImageContext **o_enc_dict_context)
+{
+    Encoder *encoder = (Encoder *)opaque_encoder;
+    WindowImage *dict_image;
+    uint8_t *io_ptr_end = io_ptr + num_io_bytes;
+    uint32_t win_head_image_dist;
+
+    if (IS_IMAGE_TYPE_PLT[type]) {
+        if (stride > (width / PLT_PIXELS_PER_BYTE[type])) {
+            if (((width % PLT_PIXELS_PER_BYTE[type]) == 0) || (
+                    (stride - (width / PLT_PIXELS_PER_BYTE[type])) > 1)) {
+                encoder->usr->error(encoder->usr, "sride overflows (plt)\n");
+            }
+        }
+    } else {
+        if (stride != width * RGB_BYTES_PER_PIXEL[type]) {
+            encoder->usr->error(encoder->usr, "sride != width*bytes_per_pixel (rgb)\n");
+        }
+    }
+
+    // assign the output buffer
+    if (!encoder_reset(encoder, io_ptr, io_ptr_end)) {
+        encoder->usr->error(encoder->usr, "lz encoder io reset failed\n");
+    }
+
+    // first read the list of the image segments into the dictionary window
+    dict_image = glz_dictionary_pre_encode(encoder->id, encoder->usr,
+                                           encoder->dict, type, width, height, stride,
+                                           lines, num_lines, usr_context, &win_head_image_dist);
+    *o_enc_dict_context = (GlzEncDictImageContext *)dict_image;
+
+    encoder->cur_image.type = type;
+    encoder->cur_image.id = dict_image->id;
+    encoder->cur_image.first_win_seg = dict_image->first_seg;
+
+    encode_32(encoder, LZ_MAGIC);
+    encode_32(encoder, LZ_VERSION);
+    if (top_down) {
+        encode(encoder, (type & LZ_IMAGE_TYPE_MASK) | (1 << LZ_IMAGE_TYPE_LOG));
+    } else {
+        encode(encoder, (type & LZ_IMAGE_TYPE_MASK));
+    }
+
+    encode_32(encoder, width);
+    encode_32(encoder, height);
+    encode_32(encoder, stride);
+    encode_64(encoder, dict_image->id);
+    encode_32(encoder, win_head_image_dist);
+
+    switch (encoder->cur_image.type) {
+    case LZ_IMAGE_TYPE_PLT1_BE:
+    case LZ_IMAGE_TYPE_PLT1_LE:
+    case LZ_IMAGE_TYPE_PLT4_BE:
+    case LZ_IMAGE_TYPE_PLT4_LE:
+    case LZ_IMAGE_TYPE_PLT8:
+        glz_plt_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB16:
+        glz_rgb16_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB24:
+        glz_rgb24_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGB32:
+        glz_rgb32_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_RGBA:
+        glz_rgb32_compress(encoder);
+        glz_rgb_alpha_compress(encoder);
+        break;
+    case LZ_IMAGE_TYPE_INVALID:
+    default:
+        encoder->usr->error(encoder->usr, "bad image type\n");
+    }
+
+    glz_dictionary_post_encode(encoder->id, encoder->usr, encoder->dict);
+
+    // move all the used segments to the free ones
+    encoder->io.bytes_count -= (encoder->io.end - encoder->io.now);
+
+    return encoder->io.bytes_count;
+}
+
diff --git a/server/glz_encoder.h b/server/glz_encoder.h
new file mode 100644
index 00000000..b324a68d
--- /dev/null
+++ b/server/glz_encoder.h
@@ -0,0 +1,56 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_ENCODER
+#define _H_GLZ_ENCODER
+
+/* Manging the lz encoding using a dictionary that is shared among encoders */
+
+#include <stdint.h>
+#include "lz_common.h"
+#include "glz_encoder_dictionary.h"
+#include "glz_encoder_config.h"
+
+typedef void GlzEncoderContext;
+
+GlzEncoderContext *glz_encoder_create(uint8_t id, GlzEncDictContext *dictionary,
+                                      GlzEncoderUsrContext *usr);
+
+void glz_encoder_destroy(GlzEncoderContext *opaque_encoder);
+
+/*
+        assumes width is in pixels and stride is in bytes
+    usr_context       : when an image is released from the window due to capicity overflow,
+                        usr_context is given as a parmater to the free_image callback.
+    o_enc_dict_context: if glz_enc_dictionary_remove_image is called, it should be
+                        called with the o_enc_dict_context that is associated with
+                        the image.
+
+        return: the number of bytes in the compressed data and sets o_enc_dict_context
+
+        NOTE  :	currently supports only rgb images in which width*bytes_per_pixel = stride OR
+                palette images in which stride eqauls the min number of bytes to hold a line.
+                The stride should be > 0
+*/
+int glz_encode(GlzEncoderContext *opaque_encoder, LzImageType type, int width, int height,
+               int top_down, uint8_t *lines, unsigned int num_lines, int stride,
+               uint8_t *io_ptr, unsigned int num_io_bytes, GlzUsrImageContext *usr_context,
+               GlzEncDictImageContext **o_enc_dict_context);
+
+
+#endif // _H_GLZ_ENCODER
+
diff --git a/server/glz_encoder_config.h b/server/glz_encoder_config.h
new file mode 100644
index 00000000..a2b9b580
--- /dev/null
+++ b/server/glz_encoder_config.h
@@ -0,0 +1,64 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_ENCODER_CONFIG
+#define _H_GLZ_ENCODER_CONFIG
+
+#include "lz_common.h"
+
+typedef void GlzUsrImageContext;
+typedef struct GlzEncoderUsrContext GlzEncoderUsrContext;
+
+struct GlzEncoderUsrContext {
+    void (*error)(GlzEncoderUsrContext *usr, const char *fmt, ...);
+    void (*warn)(GlzEncoderUsrContext *usr, const char *fmt, ...);
+    void (*info)(GlzEncoderUsrContext *usr, const char *fmt, ...);
+    void    *(*malloc)(GlzEncoderUsrContext *usr, int size);
+    void (*free)(GlzEncoderUsrContext *usr, void *ptr);
+
+    // get the next chunk of the image which is entered to the dictionary. If the image is down to
+    // top, return it from the last line to the first one (stride should always be positive)
+    int (*more_lines)(GlzEncoderUsrContext *usr, uint8_t **lines);
+
+    // get the next chunk of the compressed buffer.return number of bytes in the chunk.
+    int (*more_space)(GlzEncoderUsrContext *usr, uint8_t **io_ptr);
+
+    // called when an image is removed from the dictionary, due to the window size limit
+    void (*free_image)(GlzEncoderUsrContext *usr, GlzUsrImageContext *image);
+
+};
+
+
+#ifdef DEBUG
+
+#define GLZ_ASSERT(usr, x) \
+    if (!(x)) (usr)->error(usr, "%s: ASSERT %s failed\n", __FUNCTION__, #x);
+
+#else
+
+#define GLZ_ASSERT(usr, x)
+
+#endif
+
+#define INLINE inline
+
+#define FALSE 0
+#define TRUE 1
+
+
+#endif
+
diff --git a/server/glz_encoder_dictionary.c b/server/glz_encoder_dictionary.c
new file mode 100644
index 00000000..8ea8065f
--- /dev/null
+++ b/server/glz_encoder_dictionary.c
@@ -0,0 +1,618 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <pthread.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "glz_encoder_dictionary.h"
+#include "glz_encoder_dictionary_protected.h"
+
+/* turning all used images to free ones. If they are alive, calling the free_image callback for
+   each one */
+static INLINE void __glz_dictionary_window_reset_images(SharedDictionary *dict)
+{
+    WindowImage *tmp;
+
+    while (dict->window.used_images_head) {
+        tmp = dict->window.used_images_head;
+        dict->window.used_images_head = dict->window.used_images_head->next;
+        if (tmp->is_alive) {
+            dict->cur_usr->free_image(dict->cur_usr, tmp->usr_context);
+        }
+        tmp->next = dict->window.free_images;
+        tmp->is_alive = FALSE;
+        dict->window.free_images = tmp;
+    }
+    dict->window.used_images_tail = NULL;
+}
+
+/* allocate window fields (no reset)*/
+static int glz_dictionary_window_create(SharedDictionary *dict, uint32_t size)
+{
+    if (size > LZ_MAX_WINDOW_SIZE) {
+        return FALSE;
+    }
+
+    dict->window.size_limit = size;
+    dict->window.segs = (WindowImageSegment *)(
+            dict->cur_usr->malloc(dict->cur_usr, sizeof(WindowImageSegment) * INIT_IMAGE_SEGS_NUM));
+
+    if (!dict->window.segs) {
+        return FALSE;
+    }
+
+    dict->window.segs_quota = INIT_IMAGE_SEGS_NUM;
+
+    dict->window.encoders_heads = (uint32_t *)dict->cur_usr->malloc(dict->cur_usr,
+                                                            sizeof(uint32_t) * dict->max_encdoers);
+
+    if (!dict->window.encoders_heads) {
+        dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+        return FALSE;
+    }
+
+    dict->window.used_images_head = NULL;
+    dict->window.used_images_tail = NULL;
+    dict->window.free_images = NULL;
+    dict->window.pixels_so_far = 0;
+
+    return TRUE;
+}
+
+/* initializes an empty window (segs and encoder_heads should be pre allocated.
+   resets the image infos, and calls the free_image usr callback*/
+static void glz_dictionary_window_reset(SharedDictionary *dict)
+{
+    uint32_t i;
+    WindowImageSegment *seg, *last_seg;
+
+    last_seg = dict->window.segs + dict->window.segs_quota;
+    /* reset free segs list */
+    dict->window.free_segs_head = 0;
+    for (seg = dict->window.segs, i = 0; seg < last_seg; seg++, i++) {
+        seg->next = i + 1;
+        seg->image = NULL;
+        seg->lines = NULL;
+        seg->lines_end = NULL;
+        seg->pixels_num = 0;
+        seg->pixels_so_far = 0;
+    }
+    dict->window.segs[dict->window.segs_quota - 1].next = NULL_IMAGE_SEG_ID;
+
+    dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
+    dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
+
+    // reset encoders heads
+    for (i = 0; i < dict->max_encdoers; i++) {
+        dict->window.encoders_heads[i] = NULL_IMAGE_SEG_ID;
+    }
+
+    __glz_dictionary_window_reset_images(dict);
+}
+
+static INLINE void glz_dictionary_reset_hash(SharedDictionary *dict)
+{
+    memset(dict->htab, 0, sizeof(HashEntry) * HASH_SIZE * HASH_CHAIN_SIZE);
+#ifdef CHAINED_HASH
+    memset(dict->htab_counter, 0, HASH_SIZE * sizeof(uint8_t));
+#endif
+}
+
+static INLINE void glz_dictionary_window_destroy(SharedDictionary *dict)
+{
+    __glz_dictionary_window_reset_images(dict);
+
+    if (dict->window.segs) {
+        dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+        dict->window.segs = NULL;
+    }
+
+    while (dict->window.free_images) {
+        WindowImage *tmp = dict->window.free_images;
+        dict->window.free_images = tmp->next;
+
+        dict->cur_usr->free(dict->cur_usr, tmp);
+    }
+
+    if (dict->window.encoders_heads) {
+        dict->cur_usr->free(dict->cur_usr, dict->window.encoders_heads);
+        dict->window.encoders_heads = NULL;
+    }
+}
+
+/* logic removal only */
+static INLINE void glz_dictionary_window_kill_image(SharedDictionary *dict, WindowImage *image)
+{
+    image->is_alive = FALSE;
+}
+
+GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
+                                             GlzEncoderUsrContext *usr)
+{
+    SharedDictionary *dict;
+
+    if (!(dict = (SharedDictionary *)usr->malloc(usr,
+                                                 sizeof(SharedDictionary)))) {
+        return NULL;
+    }
+
+    dict->cur_usr = usr;
+    dict->last_image_id = 0;
+    dict->max_encdoers = max_encoders;
+
+    pthread_mutex_init(&dict->lock, NULL);
+    pthread_rwlock_init(&dict->rw_alloc_lock, NULL);
+
+    dict->window.encoders_heads = NULL;
+
+    // alloc window fields and reset
+    if (!glz_dictionary_window_create(dict, size)) {
+        dict->cur_usr->free(usr, dict);
+        return NULL;
+    }
+
+    // reset window and hash
+    glz_enc_dictionary_reset((GlzEncDictContext *)dict, usr);
+
+    return (GlzEncDictContext *)dict;
+}
+
+void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
+                                         GlzEncDictRestoreData *out_data, GlzEncoderUsrContext *usr)
+{
+    SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+    dict->cur_usr = usr;
+    GLZ_ASSERT(dict->cur_usr, opaque_dict);
+    GLZ_ASSERT(dict->cur_usr, out_data);
+
+    out_data->last_image_id = dict->last_image_id;
+    out_data->max_encoders = dict->max_encdoers;
+    out_data->size = dict->window.size_limit;
+}
+
+GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
+                                              GlzEncoderUsrContext *usr)
+{
+    if (!restore_data) {
+        return NULL;
+    }
+    SharedDictionary *ret = (SharedDictionary *)glz_enc_dictionary_create(
+            restore_data->size, restore_data->max_encoders, usr);
+    ret->last_image_id = restore_data->last_image_id;
+    return ((GlzEncDictContext *)ret);
+}
+
+void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
+{
+    SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+    dict->cur_usr = usr;
+    GLZ_ASSERT(dict->cur_usr, opaque_dict);
+
+    dict->last_image_id = 0;
+    glz_dictionary_window_reset(dict);
+    glz_dictionary_reset_hash(dict);
+}
+
+void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr)
+{
+    SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+
+    if (!opaque_dict) {
+        return;
+    }
+
+    dict->cur_usr = usr;
+    glz_dictionary_window_destroy(dict);
+
+    pthread_mutex_destroy(&dict->lock);
+    pthread_rwlock_destroy(&dict->rw_alloc_lock);
+
+    dict->cur_usr->free(dict->cur_usr, dict);
+}
+
+uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *opaque_dict)
+{
+    SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+
+    if (!opaque_dict) {
+        return 0;
+    }
+    return dict->window.size_limit;
+}
+
+/* doesn't call the remove image callback */
+void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
+                                     GlzEncDictImageContext *opaque_image,
+                                     GlzEncoderUsrContext *usr)
+{
+    SharedDictionary *dict = (SharedDictionary *)opaque_dict;
+    WindowImage *image = (WindowImage *)opaque_image;
+    dict->cur_usr = usr;
+    GLZ_ASSERT(dict->cur_usr, opaque_image && opaque_dict);
+
+    glz_dictionary_window_kill_image(dict, image);
+}
+
+/***********************************************************************************
+ Mutators of the window. Should be called by the encoder before and after encoding.
+ ***********************************************************************************/
+
+static INLINE int __get_pixels_num(LzImageType image_type, unsigned int num_lines, int stride)
+{
+    if (IS_IMAGE_TYPE_RGB[image_type]) {
+        return num_lines * stride / RGB_BYTES_PER_PIXEL[image_type];
+    } else {
+        return num_lines * stride * PLT_PIXELS_PER_BYTE[image_type];
+    }
+}
+
+static void __glz_dictionary_window_segs_realloc(SharedDictionary *dict)
+{
+    WindowImageSegment *new_segs;
+    uint32_t new_quota = (MAX_IMAGE_SEGS_NUM < (dict->window.segs_quota * 2)) ?
+        MAX_IMAGE_SEGS_NUM : (dict->window.segs_quota * 2);
+    WindowImageSegment *seg;
+    uint32_t i;
+
+    pthread_rwlock_wrlock(&dict->rw_alloc_lock);
+
+    if (dict->window.segs_quota == MAX_IMAGE_SEGS_NUM) {
+        dict->cur_usr->error(dict->cur_usr, "overflow in image segments window\n");
+    }
+
+    new_segs = (WindowImageSegment*)dict->cur_usr->malloc(
+            dict->cur_usr, sizeof(WindowImageSegment) * new_quota);
+
+    if (!new_segs) {
+        dict->cur_usr->error(dict->cur_usr,
+                             "realloc of dictionary window failed\n");
+    }
+
+    memcpy(new_segs, dict->window.segs,
+           sizeof(WindowImageSegment) * dict->window.segs_quota);
+
+    // reseting the new elements
+    for (i = dict->window.segs_quota, seg = new_segs + i; i < new_quota; i++, seg++) {
+        seg->image = NULL;
+        seg->lines = NULL;
+        seg->lines_end = NULL;
+        seg->pixels_num = 0;
+        seg->pixels_so_far = 0;
+        seg->next = i + 1;
+    }
+    new_segs[new_quota - 1].next = dict->window.free_segs_head;
+    dict->window.free_segs_head = dict->window.segs_quota;
+
+    dict->cur_usr->free(dict->cur_usr, dict->window.segs);
+    dict->window.segs = new_segs;
+    dict->window.segs_quota = new_quota;
+
+    pthread_rwlock_unlock(&dict->rw_alloc_lock);
+}
+
+/* NOTE - it also updates the used_images_list*/
+static WindowImage *__glz_dictionary_window_alloc_image(SharedDictionary *dict)
+{
+    WindowImage *ret;
+
+    if (dict->window.free_images) {
+        ret = dict->window.free_images;
+        dict->window.free_images = ret->next;
+    } else {
+        if (!(ret = (WindowImage *)dict->cur_usr->malloc(dict->cur_usr,
+                                                         sizeof(*ret)))) {
+            return NULL;
+        }
+    }
+
+    ret->next = NULL;
+    if (dict->window.used_images_tail) {
+        dict->window.used_images_tail->next = ret;
+    }
+    dict->window.used_images_tail = ret;
+
+    if (!dict->window.used_images_head) {
+        dict->window.used_images_head = ret;
+    }
+    return ret;
+}
+
+/* NOTE - it also updates the used_segs_list*/
+static uint32_t __glz_dictionary_window_alloc_image_seg(SharedDictionary *dict)
+{
+    uint32_t seg_id;
+    WindowImageSegment *seg;
+
+    // TODO: when is it best to realloc? when full or when half full?
+    if (dict->window.free_segs_head == NULL_IMAGE_SEG_ID) {
+        __glz_dictionary_window_segs_realloc(dict);
+    }
+
+    GLZ_ASSERT(dict->cur_usr, dict->window.free_segs_head != NULL_IMAGE_SEG_ID);
+
+    seg_id = dict->window.free_segs_head;
+    seg = dict->window.segs + seg_id;
+    dict->window.free_segs_head = seg->next;
+
+    // first segment
+    if (dict->window.used_segs_tail == NULL_IMAGE_SEG_ID) {
+        dict->window.used_segs_head = seg_id;
+        dict->window.used_segs_tail = seg_id;
+    } else {
+        int prev_tail = dict->window.used_segs_tail;
+        dict->window.segs[prev_tail].next = seg_id;
+        dict->window.used_segs_tail = seg_id;
+    }
+
+    seg->next = NULL_IMAGE_SEG_ID;
+
+    return seg_id;
+}
+
+/* moves image to free list and "kill" it. Calls the free_image callback if was alive. */
+static INLINE void __glz_dictionary_window_free_image(SharedDictionary *dict, WindowImage *image)
+{
+    if (image->is_alive) {
+        dict->cur_usr->free_image(dict->cur_usr, image->usr_context);
+    }
+    image->is_alive = FALSE;
+    image->next = dict->window.free_images;
+    dict->window.free_images = image;
+}
+
+/* moves all the segments that were associaed with the images to the free segments */
+static INLINE void __glz_dictionary_window_free_image_segs(SharedDictionary *dict,
+                                                           WindowImage *image)
+{
+    uint32_t old_free_head = dict->window.free_segs_head;
+    uint32_t seg_id, next_seg_id;
+
+    GLZ_ASSERT(dict->cur_usr, image->first_seg != NULL_IMAGE_SEG_ID);
+    dict->window.free_segs_head = image->first_seg;
+
+    // retrieving the last segment of the image
+    for (seg_id = image->first_seg, next_seg_id = dict->window.segs[seg_id].next;
+         (next_seg_id != NULL_IMAGE_SEG_ID) && (dict->window.segs[next_seg_id].image == image);
+         seg_id = next_seg_id, next_seg_id = dict->window.segs[seg_id].next) {
+    }
+
+    // concatenate the free list
+    dict->window.segs[seg_id].next = old_free_head;
+}
+
+/* Returns the logical head of the window after we add an image with the give size to its tail.
+   Returns NULL when the window is empty, of when we have to empty the window in order
+   to insert the new image. */
+static WindowImage *glz_dictionary_window_get_new_head(SharedDictionary *dict, int new_image_size)
+{
+    uint32_t cur_win_size;
+    WindowImage *cur_head;
+
+    if ((uint32_t)new_image_size > dict->window.size_limit) {
+        dict->cur_usr->error(dict->cur_usr, "image is bigger than window\n");
+    }
+
+    GLZ_ASSERT(dict->cur_usr, new_image_size < dict->window.size_limit)
+
+    // the window is empty
+    if (!dict->window.used_images_head) {
+        return NULL;
+    }
+
+    GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_head != NULL_IMAGE_SEG_ID);
+    GLZ_ASSERT(dict->cur_usr, dict->window.used_segs_tail != NULL_IMAGE_SEG_ID);
+
+    // used_segs_head is the latest logical head (the physical head may preceed it)
+    cur_head = dict->window.segs[dict->window.used_segs_head].image;
+    cur_win_size = dict->window.segs[dict->window.used_segs_tail].pixels_num +
+        dict->window.segs[dict->window.used_segs_tail].pixels_so_far -
+        dict->window.segs[dict->window.used_segs_head].pixels_so_far;
+
+    while ((cur_win_size + new_image_size) > dict->window.size_limit) {
+        GLZ_ASSERT(dict->cur_usr, cur_head);
+        cur_win_size -= cur_head->size;
+        cur_head = cur_head->next;
+    }
+
+    return cur_head;
+}
+
+static INLINE int glz_dictionary_is_in_use(SharedDictionary *dict)
+{
+    uint32_t i = 0;
+    for (i = 0; i < dict->max_encdoers; i++) {
+        if (dict->window.encoders_heads[i] != NULL_IMAGE_SEG_ID) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+/* remove from the window (and free relevant data) the images between the oldest physical head
+   (inclusive) and the end_image (exclusive). If end_image is NULL, empties the window*/
+static void glz_dictionary_window_remove_head(SharedDictionary *dict, uint32_t encoder_id,
+                                              WindowImage *end_image)
+{
+    // note that the segs list heads (one per econder) may be different than the
+    // used_segs_head and it is updated somewhere else
+    while (dict->window.used_images_head != end_image) {
+        WindowImage *image = dict->window.used_images_head;
+
+        __glz_dictionary_window_free_image_segs(dict, image);
+        dict->window.used_images_head = image->next;
+        __glz_dictionary_window_free_image(dict, image);
+    }
+
+    if (!dict->window.used_images_head) {
+        dict->window.used_segs_head = NULL_IMAGE_SEG_ID;
+        dict->window.used_segs_tail = NULL_IMAGE_SEG_ID;
+        dict->window.used_images_tail = NULL;
+    } else {
+        dict->window.used_segs_head = end_image->first_seg;
+    }
+}
+
+static uint32_t glz_dictionary_window_add_image_seg(SharedDictionary *dict, WindowImage* image,
+                                                    int size, int stride,
+                                                    uint8_t *lines, unsigned int num_lines)
+{
+    uint32_t seg_id = __glz_dictionary_window_alloc_image_seg(dict);
+    WindowImageSegment *seg = &dict->window.segs[seg_id];
+
+    seg->image = image;
+    seg->lines = lines;
+    seg->lines_end = lines + num_lines * stride;
+    seg->pixels_num = size;
+    seg->pixels_so_far = dict->window.pixels_so_far;
+    dict->window.pixels_so_far += seg->pixels_num;
+
+    return seg_id;
+}
+
+static WindowImage *glz_dictionary_window_add_image(SharedDictionary *dict, LzImageType image_type,
+                                                    int image_size, int image_height,
+                                                    int image_stride, uint8_t *first_lines,
+                                                    unsigned int num_first_lines,
+                                                    GlzUsrImageContext *usr_image_context)
+{
+    unsigned int num_lines = num_first_lines;
+    unsigned int row;
+    uint32_t seg_id;
+    uint8_t* lines = first_lines;
+    // alloc image info,update used head tail,  if used_head null - update  head
+    WindowImage *image = __glz_dictionary_window_alloc_image(dict);
+    image->id = dict->last_image_id++;
+    image->size = image_size;
+    image->type = image_type;
+    image->usr_context = usr_image_context;
+
+    if (num_lines <= 0) {
+        num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
+        if (num_lines <= 0) {
+            dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
+        }
+    }
+
+    for (row = 0;;) {
+        seg_id = glz_dictionary_window_add_image_seg(dict, image,
+                                                     image_size * num_lines / image_height,
+                                                     image_stride,
+                                                     lines, num_lines);
+        if (row == 0) {
+            image->first_seg = seg_id;
+        }
+        row += num_lines;
+        if (row < (uint32_t)image_height) {
+            num_lines = dict->cur_usr->more_lines(dict->cur_usr, &lines);
+            if (num_lines <= 0) {
+                dict->cur_usr->error(dict->cur_usr, "more lines failed\n");
+            }
+        } else {
+            break;
+        }
+    }
+    image->is_alive = TRUE;
+
+    return image;
+}
+
+WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+                                       SharedDictionary *dict, LzImageType image_type,
+                                       int image_width, int image_height, int image_stride,
+                                       uint8_t *first_lines, unsigned int num_first_lines,
+                                       GlzUsrImageContext *usr_image_context,
+                                       uint32_t *image_head_dist)
+{
+    WindowImage *new_win_head, *ret;
+    int image_size;
+
+
+    pthread_mutex_lock(&dict->lock);
+
+    dict->cur_usr = usr;
+    GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] == NULL_IMAGE_SEG_ID);
+
+    image_size = __get_pixels_num(image_type, image_height, image_stride);
+    new_win_head = glz_dictionary_window_get_new_head(dict, image_size);
+
+    if (!glz_dictionary_is_in_use(dict)) {
+        glz_dictionary_window_remove_head(dict, encoder_id, new_win_head);
+    }
+
+    ret = glz_dictionary_window_add_image(dict, image_type, image_size, image_height, image_stride,
+                                          first_lines, num_first_lines, usr_image_context);
+
+    if (new_win_head) {
+        dict->window.encoders_heads[encoder_id] = new_win_head->first_seg;
+        *image_head_dist = (uint32_t)(ret->id - new_win_head->id); // shouldn't be greater than 32
+                                                                   // bit because the window size is
+                                                                   // limited to 2^25
+    } else {
+        dict->window.encoders_heads[encoder_id] = ret->first_seg;
+        *image_head_dist = 0;
+    }
+
+
+    // update encoders head  (the other heads were already updated)
+    pthread_mutex_unlock(&dict->lock);
+    pthread_rwlock_rdlock(&dict->rw_alloc_lock);
+    return ret;
+}
+
+void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+                                SharedDictionary *dict)
+{
+    uint32_t i;
+    uint32_t early_head_seg = NULL_IMAGE_SEG_ID;
+    uint32_t this_encoder_head_seg;
+
+    pthread_rwlock_unlock(&dict->rw_alloc_lock);
+    pthread_mutex_lock(&dict->lock);
+    dict->cur_usr = usr;
+
+    GLZ_ASSERT(dict->cur_usr, dict->window.encoders_heads[encoder_id] != NULL_IMAGE_SEG_ID);
+    // get the earliest head in use (not including this encoder head)
+    for (i = 0; i < dict->max_encdoers; i++) {
+        if (i != encoder_id) {
+            if (IMAGE_SEG_IS_EARLIER(dict, dict->window.encoders_heads[i], early_head_seg)) {
+                early_head_seg = dict->window.encoders_heads[i];
+            }
+        }
+    }
+
+    // possible only if early_head_seg == NULL
+    if (IMAGE_SEG_IS_EARLIER(dict, dict->window.used_segs_head, early_head_seg)) {
+        early_head_seg = dict->window.used_segs_head;
+    }
+
+    this_encoder_head_seg = dict->window.encoders_heads[encoder_id];
+
+    GLZ_ASSERT(dict->cur_usr, early_head_seg != NULL_IMAGE_SEG_ID);
+
+    if (IMAGE_SEG_IS_EARLIER(dict, this_encoder_head_seg, early_head_seg)) {
+        GLZ_ASSERT(dict->cur_usr,
+                   this_encoder_head_seg == dict->window.used_images_head->first_seg);
+        glz_dictionary_window_remove_head(dict, encoder_id,
+                                          dict->window.segs[early_head_seg].image);
+    }
+
+
+    dict->window.encoders_heads[encoder_id] = NULL_IMAGE_SEG_ID;
+    pthread_mutex_unlock(&dict->lock);
+}
+
diff --git a/server/glz_encoder_dictionary.h b/server/glz_encoder_dictionary.h
new file mode 100644
index 00000000..dbc4f4b5
--- /dev/null
+++ b/server/glz_encoder_dictionary.h
@@ -0,0 +1,70 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_ENCODER_DICTIONARY
+#define _H_GLZ_ENCODER_DICTIONARY
+
+#include <stdint.h>
+#include "glz_encoder_config.h"
+
+/*
+    Interface for maintaining lz dictionary that is shared among several encoders.
+    The interface for accessing the dictionary for encoding purposes is located in
+    glz_encoder_diciotnary_protected.h
+*/
+
+typedef void GlzEncDictContext;
+typedef void GlzEncDictImageContext;
+
+/* NOTE: DISPLAY_MIGRATE_DATA_VERSION should change in case GlzEncDictRestoreData changes*/
+typedef struct GlzEncDictRestoreData {
+    uint32_t size;
+    uint32_t max_encoders;
+    uint64_t last_image_id;
+} GlzEncDictRestoreData;
+
+/* size        : maximal number of pixels occupying the window
+   max_encoders: maximal number of encoders that use the dicitionary
+   usr         : callbacks */
+GlzEncDictContext *glz_enc_dictionary_create(uint32_t size, uint32_t max_encoders,
+                                             GlzEncoderUsrContext *usr);
+
+void glz_enc_dictionary_destroy(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
+
+/* returns the window capacity in pixels */
+uint32_t glz_enc_dictionary_get_size(GlzEncDictContext *);
+
+/* returns the current state of the dictionary.
+   NOTE - you should use it only when no encoder uses the dicitonary. */
+void glz_enc_dictionary_get_restore_data(GlzEncDictContext *opaque_dict,
+                                         GlzEncDictRestoreData *out_data,
+                                         GlzEncoderUsrContext *usr);
+
+/* creates a dictionary and initialized it by use the given info */
+GlzEncDictContext *glz_enc_dictionary_restore(GlzEncDictRestoreData *restore_data,
+                                              GlzEncoderUsrContext *usr);
+
+/*  NOTE - you should use this routine only when no encoder uses the dicitonary. */
+void glz_enc_dictionary_reset(GlzEncDictContext *opaque_dict, GlzEncoderUsrContext *usr);
+
+/* image: the context returned by the encoder when the image was encoded.
+   NOTE - you should use this routine only when no encoder uses the dicitonary.*/
+void glz_enc_dictionary_remove_image(GlzEncDictContext *opaque_dict,
+                                     GlzEncDictImageContext *image, GlzEncoderUsrContext *usr);
+
+#endif // _H_GLZ_ENCODER_DICTIONARY
+
diff --git a/server/glz_encoder_dictionary_protected.h b/server/glz_encoder_dictionary_protected.h
new file mode 100644
index 00000000..f3f4315c
--- /dev/null
+++ b/server/glz_encoder_dictionary_protected.h
@@ -0,0 +1,187 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_GLZ_ENCODER_DICTIONARY_PROTECTED
+#define _H_GLZ_ENCODER_DICTIONARY_PROTECTED
+
+/* Interface for using the dictionary for encoding.
+   Data structures are exposed for the encoder for efficiency
+   purposes. */
+typedef struct WindowImage WindowImage;
+typedef struct WindowImageSegment WindowImageSegment;
+
+
+//#define CHAINED_HASH
+
+#ifdef CHAINED_HASH
+#define HASH_SIZE_LOG 16
+#define HASH_CHAIN_SIZE 4
+#else
+#define HASH_SIZE_LOG 20
+#define HASH_CHAIN_SIZE 1
+#endif
+
+#define HASH_SIZE (1 << HASH_SIZE_LOG)
+#define HASH_MASK (HASH_SIZE - 1)
+
+typedef struct HashEntry HashEntry;
+
+typedef struct SharedDictionary SharedDictionary;
+
+struct WindowImage {
+    uint64_t id;
+    LzImageType type;
+    int size;                    // in pixels
+    uint32_t first_seg;
+    GlzUsrImageContext  *usr_context;
+    WindowImage*       next;
+    uint8_t is_alive;
+};
+
+#define MAX_IMAGE_SEGS_NUM (0xffffffff)
+#define NULL_IMAGE_SEG_ID MAX_IMAGE_SEGS_NUM
+#define INIT_IMAGE_SEGS_NUM 1000
+
+/* Images can be seperated into several chunks. The basic unit of the
+   dictionary window is one image segment. Each segment is encoded separately.
+   An encoded match can refer to only one segment.*/
+struct WindowImageSegment {
+    WindowImage     *image;
+    uint8_t         *lines;
+    uint8_t         *lines_end;
+    uint32_t pixels_num;            // Number of pixels in the segment
+    uint64_t pixels_so_far;         // Total no. pixels passed through the window till this segment.
+                                    // NOTE - never use size delta independently. It should
+                                    // always be used with respect to a previouse size delta
+    uint32_t next;
+};
+
+
+struct  __attribute__ ((__packed__)) HashEntry {
+    uint32_t image_seg_idx;
+    uint32_t ref_pix_idx;
+};
+
+
+struct SharedDictionary {
+    struct {
+        /* The segments storage. A dynamic array.
+           By reffering to a segment by its index, insetad of address,
+           we save space in the hash entries (32bit instead of 64bit) */
+        WindowImageSegment  *segs;
+        uint32_t segs_quota;
+
+        /* The window is manged as a linked list rather than as a cyclic
+           array in order to keep the indices of the segments consistent
+           after reallocation */
+
+        /* the window in a resultion of image segments */
+        uint32_t used_segs_head;             // the lateset head
+        uint32_t used_segs_tail;
+        uint32_t free_segs_head;
+
+        uint32_t            *encoders_heads; // Holds for each encoder (by id), the window head when
+                                             // it started the encoding.
+                                             // The head is NULL_IMAGE_SEG_ID when the encoder is
+                                             // not encoding.
+
+        /* the window in a resultion of images. But here the head contains the oldest head*/
+        WindowImage*        used_images_tail;
+        WindowImage*        used_images_head;
+        WindowImage*        free_images;
+
+        uint64_t pixels_so_far;
+        uint32_t size_limit;                 // max number of pixels in a window (per encoder)
+    } window;
+
+    /* Concurrency issues: the reading/wrting of each entry field should be atomic.
+       It is allowed that the reading/writing of the whole entry won't be atomic,
+       since before we access a reference we check its validity*/
+#ifdef CHAINED_HASH
+    HashEntry htab[HASH_SIZE][HASH_CHAIN_SIZE];
+    uint8_t htab_counter[HASH_SIZE];  //cyclic counter for the next entry in a chain to be assigned
+#else
+    HashEntry htab[HASH_SIZE];
+#endif
+
+    uint64_t last_image_id;
+    uint32_t max_encdoers;
+    pthread_mutex_t lock;
+    pthread_rwlock_t rw_alloc_lock;
+    GlzEncoderUsrContext       *cur_usr; // each encoder has other context.
+};
+
+/*
+    Add the image to the tail of the window.
+    If possible, release images from the head of the window.
+    Also perform concurrency related operations.
+
+    usr_image_context: when an image is released from the window due to capicity overflow,
+                       usr_image_context is given as a parmater to the free_image callback.
+
+    image_head_dist  : the number of images between the current image and the head of the
+                       window that is associated with the encoder.
+*/
+WindowImage *glz_dictionary_pre_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+                                       SharedDictionary *dict, LzImageType image_type,
+                                       int image_width, int image_height, int image_stride,
+                                       uint8_t *first_lines, unsigned int num_first_lines,
+                                       GlzUsrImageContext *usr_image_context,
+                                       uint32_t *image_head_dist);
+
+/*
+   Performs concurrency related operations.
+   If possible, release images from the head of the window.
+*/
+void glz_dictionary_post_encode(uint32_t encoder_id, GlzEncoderUsrContext *usr,
+                                SharedDictionary *dict);
+
+#define IMAGE_SEG_IS_EARLIER(dict, dst_seg, src_seg) (                     \
+    ((src_seg) == NULL_IMAGE_SEG_ID) || (((dst_seg) != NULL_IMAGE_SEG_ID)  \
+    && ((dict)->window.segs[(dst_seg)].pixels_so_far <                     \
+       (dict)->window.segs[(src_seg)].pixels_so_far)))
+
+
+#ifdef CHAINED_HASH
+#define UPDATE_HASH(dict, hval, seg, pix) {                \
+    uint8_t tmp_count = (dict)->htab_counter[hval];        \
+    (dict)->htab[hval][tmp_count].image_seg_idx = seg;     \
+    (dict)->htab[hval][tmp_count].ref_pix_idx = pix;       \
+    tmp_count = ((tmp_count) + 1) & (HASH_CHAIN_SIZE - 1); \
+    dict->htab_counter[hval] = tmp_count;                  \
+}
+#else
+#define UPDATE_HASH(dict, hval, seg, pix) { \
+    (dict)->htab[hval].image_seg_idx = seg; \
+    (dict)->htab[hval].ref_pix_idx = pix;   \
+}
+#endif
+
+/* checks if the reference segment is located in the range of the window
+   of the current encoder */
+#define REF_SEG_IS_VALID(dict, enc_id, ref_seg, src_seg) ( \
+    ((ref_seg) == (src_seg)) ||                            \
+    ((ref_seg)->image &&                                   \
+     (ref_seg)->image->is_alive &&                         \
+     (src_seg->image->type == ref_seg->image->type) &&     \
+     (ref_seg->pixels_so_far <= src_seg->pixels_so_far) && \
+     ((dict)->window.segs[                                 \
+        (dict)->window.encoders_heads[enc_id]].pixels_so_far <= \
+        ref_seg->pixels_so_far)))
+
+#endif // _H_GLZ_ENCODER_DICTIONARY_PROTECTED
+
diff --git a/server/red_bitmap_utils.h b/server/red_bitmap_utils.h
new file mode 100644
index 00000000..6153ea2f
--- /dev/null
+++ b/server/red_bitmap_utils.h
@@ -0,0 +1,162 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef RED_BITMAP_UTILS_RGB16
+#define PIXEL rgb16_pixel_t
+#define FNAME(name) name##_rgb16
+#define GET_r(pix) (((pix) >> 10) & 0x1f)
+#define GET_g(pix) (((pix) >> 5) & 0x1f)
+#define GET_b(pix) ((pix) & 0x1f)
+#endif
+
+#if defined(RED_BITMAP_UTILS_RGB24) || defined(RED_BITMAP_UTILS_RGB32)
+#define GET_r(pix) ((pix).r)
+#define GET_g(pix) ((pix).g)
+#define GET_b(pix) ((pix).b)
+#endif
+
+#ifdef RED_BITMAP_UTILS_RGB24
+#define PIXEL rgb24_pixel_t
+#define FNAME(name) name##_rgb24
+#endif
+
+#ifdef RED_BITMAP_UTILS_RGB32
+#define PIXEL rgb32_pixel_t
+#define FNAME(name) name##_rgb32
+#endif
+
+
+#define SAME_PIXEL_WEIGHT 0.5
+#define NOT_CONTRAST_PIXELS_WEIGHT -0.25
+#define CONTRAST_PIXELS_WEIGHT 1.0
+
+#ifndef RED_BITMAP_UTILS_RGB16
+#define CONTRAST_TH 60
+#else
+#define CONTRAST_TH 8
+#endif
+
+
+#define SAMPLE_JUMP 15
+#define SAME_PIXEL(p1, p2) (GET_r(p1) == GET_r(p2) && GET_g(p1) == GET_g(p2) && \
+                            GET_b(p1) == GET_b(p2))
+
+static const double FNAME(PIX_PAIR_SCORE)[] = {
+    SAME_PIXEL_WEIGHT,
+    CONTRAST_PIXELS_WEIGHT,
+    NOT_CONTRAST_PIXELS_WEIGHT,
+};
+
+// return 0 - equal, 1 - for contrast, 2 for no contrast (PIX_PAIR_SCORE is defined accordingly)
+static inline int FNAME(pixelcmp)(PIXEL p1, PIXEL p2)
+{
+    int diff = ABS(GET_r(p1) - GET_r(p2));
+    int equal;
+
+    if (diff >= CONTRAST_TH) {
+        return 1;
+    }
+    equal = !diff;
+
+    diff = ABS(GET_g(p1) - GET_g(p2));
+
+    if (diff >= CONTRAST_TH) {
+        return 1;
+    }
+
+    equal = equal && !diff;
+
+    diff = ABS(GET_b(p1) - GET_b(p2));
+    if (diff >= CONTRAST_TH) {
+        return 1;
+    }
+    equal = equal && !diff;
+
+    if (equal) {
+        return 0;
+    } else {
+        return 2;
+    }
+}
+
+static inline double FNAME(pixels_square_score)(PIXEL *line1, PIXEL *line2)
+{
+    double ret = 0.0;
+    int all_ident = TRUE;
+    int cmp_res;
+    cmp_res = FNAME(pixelcmp)(*line1, line1[1]);
+    all_ident = all_ident && (!cmp_res);
+    ret += FNAME(PIX_PAIR_SCORE)[cmp_res];
+    cmp_res = FNAME(pixelcmp)(*line1, *line2);
+    all_ident = all_ident && (!cmp_res);
+    ret += FNAME(PIX_PAIR_SCORE)[cmp_res];
+    cmp_res = FNAME(pixelcmp)(*line1, line2[1]);
+    all_ident = all_ident && (!cmp_res);
+    ret += FNAME(PIX_PAIR_SCORE)[cmp_res];
+
+    // ignore squares where al pixels are identical
+    if (all_ident) {
+        ret -= (FNAME(PIX_PAIR_SCORE)[0]) * 3;
+    }
+
+    return ret;
+}
+
+static void FNAME(compute_lines_gradual_score)(PIXEL *lines, int width, int num_lines,
+                                               double *o_samples_sum_score, int *o_num_samples)
+{
+    int jump = (SAMPLE_JUMP % width) ? SAMPLE_JUMP : SAMPLE_JUMP - 1;
+    PIXEL *cur_pix = lines + width / 2;
+    PIXEL *bottom_pix;
+    PIXEL *last_line = lines + (num_lines - 1) * width;
+
+    if ((width <= 1) || (num_lines <= 1)) {
+        *o_num_samples = 1;
+        *o_samples_sum_score = 1.0;
+        return;
+    }
+
+    *o_samples_sum_score = 0;
+    *o_num_samples = 0;
+
+    while (cur_pix < last_line) {
+        if ((cur_pix + 1 - lines) % width == 0) { // last pixel in the row
+            cur_pix--; // jump is bigger than 1 so we will not enter endless loop
+        }
+        bottom_pix = cur_pix + width;
+        (*o_samples_sum_score) += FNAME(pixels_square_score)(cur_pix, bottom_pix);
+        (*o_num_samples)++;
+        cur_pix += jump;
+    }
+
+    (*o_num_samples) *= 3;
+}
+
+#undef PIXEL
+#undef FNAME
+#undef SAME_PIXEL
+#undef GET_r
+#undef GET_g
+#undef GET_b
+#undef RED_BITMAP_UTILS_RGB16
+#undef RED_BITMAP_UTILS_RGB24
+#undef RED_BITMAP_UTILS_RGB32
+#undef SAMPLE_JUMP
+#undef CONTRAST_TH
+#undef SAME_PIXEL_WEIGHT
+#undef NOT_CONTRAST_PIXELS_WEIGHT
+
diff --git a/server/red_client_cache.h b/server/red_client_cache.h
new file mode 100644
index 00000000..c7b40e2f
--- /dev/null
+++ b/server/red_client_cache.h
@@ -0,0 +1,136 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#if defined(CLIENT_CURSOR_CACHE)
+
+#define CACHE_NAME cursor_cache
+#define CACHE_HASH_KEY CURSOR_CACHE_HASH_KEY
+#define CACHE_HASH_SIZE CURSOR_CACHE_HASH_SIZE
+#define CACHE_INVAL_TYPE RED_CURSOR_INVAL_ONE
+#define FUNC_NAME(name) red_cursor_cache_##name
+#define VAR_NAME(name) cursor_cache_##name
+#define CHANNEL CursorChannel
+
+#elif defined(CLIENT_PALETTE_CACHE)
+
+#define CACHE_NAME palette_cache
+#define CACHE_HASH_KEY PALETTE_CACHE_HASH_KEY
+#define CACHE_HASH_SIZE PALETTE_CACHE_HASH_SIZE
+#define CACHE_INVAL_TYPE RED_DISPLAY_INVAL_PALETTE
+#define FUNC_NAME(name) red_palette_cache_##name
+#define VAR_NAME(name) palette_cache_##name
+#define CHANNEL DisplayChannel
+#else
+
+#error "no cache type."
+
+#endif
+
+static CacheItem *FUNC_NAME(find)(CHANNEL *channel, uint64_t id)
+{
+    CacheItem *item = channel->CACHE_NAME[CACHE_HASH_KEY(id)];
+
+    while (item) {
+        if (item->id == id) {
+            ring_remove(&item->u.cache_data.lru_link);
+            ring_add(&channel->VAR_NAME(lru), &item->u.cache_data.lru_link);
+            break;
+        }
+        item = item->u.cache_data.next;
+    }
+    return item;
+}
+
+static void FUNC_NAME(remove)(CHANNEL *channel, CacheItem *item)
+{
+    CacheItem **now;
+    ASSERT(item);
+
+    now = &channel->CACHE_NAME[CACHE_HASH_KEY(item->id)];
+    for (;;) {
+        ASSERT(*now);
+        if (*now == item) {
+            *now = item->u.cache_data.next;
+            break;
+        }
+        now = &(*now)->u.cache_data.next;
+    }
+    ring_remove(&item->u.cache_data.lru_link);
+    channel->VAR_NAME(items)--;
+    channel->VAR_NAME(available) += item->size;
+
+    red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
+    red_pipe_add_tail(&channel->base, &item->u.pipe_data); // for now
+}
+
+static int FUNC_NAME(add)(CHANNEL *channel, uint64_t id, size_t size)
+{
+    CacheItem *item;
+    int key;
+
+    item = malloc(sizeof(*item));
+    if (!item) {
+        return FALSE;
+    }
+
+    channel->VAR_NAME(available) -= size;
+    while (channel->VAR_NAME(available) < 0) {
+        CacheItem *tail = (CacheItem *)ring_get_tail(&channel->VAR_NAME(lru));
+        if (!tail) {
+            channel->VAR_NAME(available) += size;
+            free(item);
+            return FALSE;
+        }
+        FUNC_NAME(remove)(channel, tail);
+    }
+    ++channel->VAR_NAME(items);
+    item->u.cache_data.next = channel->CACHE_NAME[(key = CACHE_HASH_KEY(id))];
+    channel->CACHE_NAME[key] = item;
+    ring_item_init(&item->u.cache_data.lru_link);
+    ring_add(&channel->VAR_NAME(lru), &item->u.cache_data.lru_link);
+    item->id = id;
+    item->size = size;
+    item->inval_type = CACHE_INVAL_TYPE;
+    return TRUE;
+}
+
+static void FUNC_NAME(reset)(CHANNEL *channel, long size)
+{
+    int i;
+
+    for (i = 0; i < CACHE_HASH_SIZE; i++) {
+        while (channel->CACHE_NAME[i]) {
+            CacheItem *item = channel->CACHE_NAME[i];
+            channel->CACHE_NAME[i] = item->u.cache_data.next;
+            free(item);
+        }
+    }
+    ring_init(&channel->VAR_NAME(lru));
+    channel->VAR_NAME(available) = size;
+    channel->VAR_NAME(items) = 0;
+}
+
+
+#undef CACHE_NAME
+#undef CACHE_HASH_KEY
+#undef CACHE_HASH_SIZE
+#undef CACHE_INVAL_TYPE
+#undef CACHE_MAX_CLIENT_SIZE
+#undef FUNC_NAME
+#undef VAR_NAME
+#undef CHANNEL
+
diff --git a/server/red_client_shared_cache.h b/server/red_client_shared_cache.h
new file mode 100644
index 00000000..1d3c4528
--- /dev/null
+++ b/server/red_client_shared_cache.h
@@ -0,0 +1,216 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#if defined(CLIENT_PIXMAPS_CACHE)
+
+#define CACHE PixmapCache
+
+#define CACHE_NAME bits_cache
+#define CACHE_HASH_KEY BITS_CACHE_HASH_KEY
+#define CACHE_HASH_SIZE BITS_CACHE_HASH_SIZE
+#define PIPE_ITEM_TYPE PIPE_ITEM_TYPE_INVAL_PIXMAP
+#define FUNC_NAME(name) pixmap_cache_##name
+#define PRIVATE_FUNC_NAME(name) __pixmap_cache_##name
+#define CHANNEL DisplayChannel
+#define CACH_GENERATION pixmap_cache_generation
+#define INVAL_ALL_VERB RED_DISPLAY_INVAL_ALL_PIXMAPS
+#else
+
+#error "no cache type."
+
+#endif
+
+
+static int FUNC_NAME(hit)(CACHE *cache, uint64_t id, CHANNEL *channel)
+{
+    NewCacheItem *item;
+    uint64_t serial;
+
+    serial = channel_message_serial((RedChannel *)channel);
+    pthread_mutex_lock(&cache->lock);
+    item = cache->hash_table[CACHE_HASH_KEY(id)];
+
+    while (item) {
+        if (item->id == id) {
+            ring_remove(&item->lru_link);
+            ring_add(&cache->lru, &item->lru_link);
+            ASSERT(channel->base.id < MAX_CACHE_CLIENTS)
+            item->sync[channel->base.id] = serial;
+            cache->sync[channel->base.id] = serial;
+            break;
+        }
+        item = item->next;
+    }
+    pthread_mutex_unlock(&cache->lock);
+
+    return !!item;
+}
+
+static int FUNC_NAME(add)(CACHE *cache, uint64_t id, uint32_t size, CHANNEL *channel)
+{
+    NewCacheItem *item;
+    uint64_t serial;
+    int key;
+
+    ASSERT(size > 0);
+
+    item = malloc(sizeof(*item));
+    if (!item) {
+        return FALSE;
+    }
+    serial = channel_message_serial((RedChannel *)channel);
+
+    pthread_mutex_lock(&cache->lock);
+
+    if (cache->generation != channel->CACH_GENERATION) {
+        if (!channel->pending_pixmaps_sync) {
+            red_pipe_add_type((RedChannel *)channel, PIPE_ITEM_TYPE_PIXMAP_SYNC);
+            channel->pending_pixmaps_sync = TRUE;
+        }
+        pthread_mutex_unlock(&cache->lock);
+        free(item);
+        return FALSE;
+    }
+
+    cache->available -= size;
+    while (cache->available < 0) {
+        NewCacheItem *tail;
+        NewCacheItem **now;
+
+        if (!(tail = (NewCacheItem *)ring_get_tail(&cache->lru)) ||
+                                                   tail->sync[channel->base.id] == serial) {
+            cache->available += size;
+            pthread_mutex_unlock(&cache->lock);
+            free(item);
+            return FALSE;
+        }
+
+        now = &cache->hash_table[CACHE_HASH_KEY(tail->id)];
+        for (;;) {
+            ASSERT(*now);
+            if (*now == tail) {
+                *now = tail->next;
+                break;
+            }
+            now = &(*now)->next;
+        }
+        ring_remove(&tail->lru_link);
+        cache->items--;
+        cache->available += tail->size;
+        cache->sync[channel->base.id] = serial;
+        display_channel_push_release(channel, RED_RES_TYPE_PIXMAP, tail->id, tail->sync);
+        free(tail);
+    }
+    ++cache->items;
+    item->next = cache->hash_table[(key = CACHE_HASH_KEY(id))];
+    cache->hash_table[key] = item;
+    ring_item_init(&item->lru_link);
+    ring_add(&cache->lru, &item->lru_link);
+    item->id = id;
+    item->size = size;
+    memset(item->sync, 0, sizeof(item->sync));
+    item->sync[channel->base.id] = serial;
+    cache->sync[channel->base.id] = serial;
+    pthread_mutex_unlock(&cache->lock);
+    return TRUE;
+}
+
+static void PRIVATE_FUNC_NAME(clear)(CACHE *cache)
+{
+    NewCacheItem *item;
+
+    if (cache->freezed) {
+        cache->lru.next = cache->freezed_head;
+        cache->lru.prev = cache->freezed_tail;
+        cache->freezed = FALSE;
+    }
+
+    while ((item = (NewCacheItem *)ring_get_head(&cache->lru))) {
+        ring_remove(&item->lru_link);
+        free(item);
+    }
+    memset(cache->hash_table, 0, sizeof(*cache->hash_table) * CACHE_HASH_SIZE);
+
+    cache->available = cache->size;
+    cache->items = 0;
+}
+
+static void FUNC_NAME(reset)(CACHE *cache, CHANNEL *channel, RedWaitForChannels* sync_data)
+{
+    uint8_t wait_count;
+    uint64_t serial;
+    uint32_t i;
+
+    serial = channel_message_serial((RedChannel *)channel);
+    pthread_mutex_lock(&cache->lock);
+    PRIVATE_FUNC_NAME(clear)(cache);
+
+    channel->CACH_GENERATION = ++cache->generation;
+    cache->generation_initiator.client = channel->base.id;
+    cache->generation_initiator.message = serial;
+    cache->sync[channel->base.id] = serial;
+
+    wait_count = 0;
+    for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
+        if (cache->sync[i] && i != channel->base.id) {
+            sync_data->wait_list[wait_count].channel_type = RED_CHANNEL_DISPLAY;
+            sync_data->wait_list[wait_count].channel_id = i;
+            sync_data->wait_list[wait_count++].message_serial = cache->sync[i];
+        }
+    }
+    sync_data->wait_count = wait_count;
+    pthread_mutex_unlock(&cache->lock);
+}
+
+static int FUNC_NAME(freeze)(CACHE *cache)
+{
+    pthread_mutex_lock(&cache->lock);
+
+    if (cache->freezed) {
+        pthread_mutex_unlock(&cache->lock);
+        return FALSE;
+    }
+
+    cache->freezed_head = cache->lru.next;
+    cache->freezed_tail = cache->lru.prev;
+    ring_init(&cache->lru);
+    memset(cache->hash_table, 0, sizeof(*cache->hash_table) * CACHE_HASH_SIZE);
+    cache->available = -1;
+    cache->freezed = TRUE;
+
+    pthread_mutex_unlock(&cache->lock);
+    return TRUE;
+}
+
+static void FUNC_NAME(destroy)(CACHE *cache)
+{
+    ASSERT(cache);
+
+    pthread_mutex_lock(&cache->lock);
+    PRIVATE_FUNC_NAME(clear)(cache);
+    pthread_mutex_unlock(&cache->lock);
+}
+
+#undef CACHE_NAME
+#undef CACHE_HASH_KEY
+#undef CACHE_HASH_SIZE
+#undef CACHE_INVAL_TYPE
+#undef CACHE_MAX_CLIENT_SIZE
+#undef FUNC_NAME
+#undef VAR_NAME
+#undef CHANNEL
+
diff --git a/server/red_common.h b/server/red_common.h
new file mode 100644
index 00000000..b397be51
--- /dev/null
+++ b/server/red_common.h
@@ -0,0 +1,99 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_COMMON
+#define _H_RED_COMMON
+
+#include <sys/uio.h>
+#include <openssl/ssl.h>
+
+#include "red.h"
+
+#ifndef MIN
+#define MIN(x, y) (((x) <= (y)) ? (x) : (y))
+#endif
+#ifndef MAX
+#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
+#endif
+
+#ifndef ABS
+#define ABS(a) ((a) >= 0 ? (a) : -(a))
+#endif
+
+#ifndef ALIGN
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+#endif
+
+#define ASSERT(x) if (!(x)) { 					\
+	printf("%s: ASSERT %s failed\n", __FUNCTION__, #x); 	\
+	abort();					        \
+}
+
+#define PANIC(str) {                              \
+    printf("%s: panic: %s\n", __FUNCTION__, str);   \
+    abort();                                        \
+}
+
+#define TRUE 1
+#define FALSE 0
+
+#define red_error(format, ...) {                                 \
+    printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );   \
+    abort();                                                     \
+}
+
+#define red_printf(format, ...) \
+    printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ )
+
+#define red_printf_once(format, ...) {                              \
+    static int do_print = TRUE;                                     \
+    if (do_print) {                                                 \
+        do_print = FALSE;                                           \
+        printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
+    }                                                               \
+}
+
+#define red_printf_some(every, format, ...) {                       \
+    static int count = 0;                                           \
+    if (count++ % (every) == 0) {                                   \
+        printf("%s: " format "\n", __FUNCTION__, ## __VA_ARGS__ );  \
+    }                                                               \
+}
+
+#define OFFSETOF(type, member) ((unsigned long)&((type *)0)->member)
+#define CONTAINEROF(ptr, type, member) \
+    ((type *)((uint8_t *)(ptr) - OFFSETOF(type, member)))
+
+typedef enum {
+    IMAGE_COMPRESS_INVALID,
+    IMAGE_COMPRESS_AUTO_GLZ,
+    IMAGE_COMPRESS_AUTO_LZ,
+    IMAGE_COMPRESS_QUIC,
+    IMAGE_COMPRESS_GLZ,
+    IMAGE_COMPRESS_LZ,
+    IMAGE_COMPRESS_OFF,
+} image_compression_t;
+
+static inline uint64_t get_time_stamp()
+{
+    struct timespec time_space;
+    clock_gettime(CLOCK_MONOTONIC, &time_space);
+    return time_space.tv_sec * 1000 * 1000 * 1000 + time_space.tv_nsec;
+}
+
+#endif
+
diff --git a/server/red_dispatcher.c b/server/red_dispatcher.c
new file mode 100644
index 00000000..58de5a33
--- /dev/null
+++ b/server/red_dispatcher.c
@@ -0,0 +1,479 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <signal.h>
+
+#include "qxl_dev.h"
+#include "vd_interface.h"
+#include "red_worker.h"
+#include "quic.h"
+#include "cairo_canvas.h"
+#include "gl_canvas.h"
+#include "reds.h"
+#include "red_dispatcher.h"
+
+static int num_active_workers = 0;
+
+//volatile
+
+typedef struct RedDispatcher RedDispatcher;
+struct RedDispatcher {
+    QXLWorker base;
+    QXLInterface *qxl_interface;
+    int channel;
+    pthread_t worker_thread;
+    uint32_t pending;
+    int active;
+    int x_res;
+    int y_res;
+    int use_hardware_cursor;
+    RedDispatcher *next;
+};
+
+typedef struct RedWorkeState {
+    uint8_t *io_base;
+    unsigned long phys_delta;
+
+    uint32_t x_res;
+    uint32_t y_res;
+    uint32_t bits;
+    uint32_t stride;
+} RedWorkeState;
+
+extern uint32_t streaming_video;
+extern image_compression_t image_compression;
+
+static RedDispatcher *dispatchers = NULL;
+
+static void red_dispatcher_set_peer(Channel *channel, RedsStreamContext *peer, int migration,
+                                    int num_common_caps, uint32_t *common_caps, int num_caps,
+                                    uint32_t *caps)
+{
+    RedDispatcher *dispatcher;
+
+    red_printf("");
+    dispatcher = (RedDispatcher *)channel->data;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_DISPLAY_CONNECT;
+    write_message(dispatcher->channel, &message);
+    send_data(dispatcher->channel, &peer, sizeof(RedsStreamContext *));
+    send_data(dispatcher->channel, &migration, sizeof(int));
+}
+
+static void red_dispatcher_shutdown_peer(Channel *channel)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
+    red_printf("");
+    RedWorkeMessage message = RED_WORKER_MESSAGE_DISPLAY_DISCONNECT;
+    write_message(dispatcher->channel, &message);
+}
+
+static void red_dispatcher_migrate(Channel *channel)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
+    red_printf("channel type %u id %u", channel->type, channel->id);
+    RedWorkeMessage message = RED_WORKER_MESSAGE_DISPLAY_MIGRATE;
+    write_message(dispatcher->channel, &message);
+}
+
+static void red_dispatcher_set_cursor_peer(Channel *channel, RedsStreamContext *peer,
+                                           int migration, int num_common_caps,
+                                           uint32_t *common_caps, int num_caps,
+                                           uint32_t *caps)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
+    red_printf("");
+    RedWorkeMessage message = RED_WORKER_MESSAGE_CURSOR_CONNECT;
+    write_message(dispatcher->channel, &message);
+    send_data(dispatcher->channel, &peer, sizeof(RedsStreamContext *));
+    send_data(dispatcher->channel, &migration, sizeof(int));
+}
+
+static void red_dispatcher_shutdown_cursor_peer(Channel *channel)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
+    red_printf("");
+    RedWorkeMessage message = RED_WORKER_MESSAGE_CURSOR_DISCONNECT;
+    write_message(dispatcher->channel, &message);
+}
+
+static void red_dispatcher_cursor_migrate(Channel *channel)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)channel->data;
+    red_printf("channel type %u id %u", channel->type, channel->id);
+    RedWorkeMessage message = RED_WORKER_MESSAGE_CURSOR_MIGRATE;
+    write_message(dispatcher->channel, &message);
+}
+
+typedef struct RendererInfo {
+    int id;
+    const char *name;
+} RendererInfo;
+
+static RendererInfo renderers_info[] = {
+    {RED_RENDERER_CAIRO, "cairo"},
+    {RED_RENDERER_OGL_PBUF, "oglpbuf"},
+    {RED_RENDERER_OGL_PIXMAP, "oglpixmap"},
+    {RED_RENDERER_INVALID, NULL},
+};
+
+static uint32_t renderers[RED_MAX_RENDERERS];
+static uint32_t num_renderers = 0;
+
+static RendererInfo *find_renderer(const char *name)
+{
+    RendererInfo *inf = renderers_info;
+    while (inf->name) {
+        if (strcmp(name, inf->name) == 0) {
+            return inf;
+        }
+        inf++;
+    }
+    return NULL;
+}
+
+int red_dispatcher_add_renderer(const char *name)
+{
+    RendererInfo *inf;
+
+    if (num_renderers == RED_MAX_RENDERERS || !(inf = find_renderer(name))) {
+        return FALSE;
+    }
+    renderers[num_renderers++] = inf->id;
+    return TRUE;
+}
+
+int red_dispatcher_qxl_count()
+{
+    return num_active_workers;
+}
+
+static void update_client_mouse_allowed()
+{
+    static int allowed = FALSE;
+    int allow_now = FALSE;
+    int x_res = 0;
+    int y_res = 0;
+
+    if (num_active_workers > 0) {
+        allow_now = TRUE;
+        RedDispatcher *now = dispatchers;
+        while (now && allow_now) {
+            if (now->active) {
+                allow_now = now->use_hardware_cursor;
+                if (num_active_workers == 1) {
+                    if (allow_now) {
+                        x_res = now->x_res;
+                        y_res = now->y_res;
+                    }
+                    break;
+                }
+            }
+            now = now->next;
+        }
+    }
+
+    if (allow_now || allow_now != allowed) {
+        allowed = allow_now;
+        reds_set_client_mouse_allowed(allowed, x_res, y_res);
+    }
+}
+
+static void qxl_worker_attach(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_ATTACH;
+    QXLDevInfo info;
+
+    dispatcher->qxl_interface->get_info(dispatcher->qxl_interface, &info);
+    dispatcher->x_res = info.x_res;
+    dispatcher->y_res = info.y_res;
+    dispatcher->use_hardware_cursor = info.use_hardware_cursor;
+    dispatcher->active = TRUE;
+
+    write_message(dispatcher->channel, &message);
+    send_data(dispatcher->channel, &info, sizeof(QXLDevInfo));
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+
+    num_active_workers++;
+    update_client_mouse_allowed();
+}
+
+static void qxl_worker_detach(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_DETACH;
+
+    write_message(dispatcher->channel, &message);
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+
+    dispatcher->x_res = 0;
+    dispatcher->y_res = 0;
+    dispatcher->use_hardware_cursor = FALSE;
+    dispatcher->active = FALSE;
+    num_active_workers--;
+    update_client_mouse_allowed();
+}
+
+static void qxl_worker_update_area(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_UPDATE;
+
+    write_message(dispatcher->channel, &message);
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+}
+
+static void qxl_worker_wakeup(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+
+    if (!test_bit(RED_WORKER_PENDING_WAKEUP, dispatcher->pending)) {
+        RedWorkeMessage message = RED_WORKER_MESSAGE_WAKEUP;
+        set_bit(RED_WORKER_PENDING_WAKEUP, &dispatcher->pending);
+        write_message(dispatcher->channel, &message);
+    }
+}
+
+static void qxl_worker_oom(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    if (!test_bit(RED_WORKER_PENDING_OOM, dispatcher->pending)) {
+        RedWorkeMessage message = RED_WORKER_MESSAGE_OOM;
+        set_bit(RED_WORKER_PENDING_OOM, &dispatcher->pending);
+        write_message(dispatcher->channel, &message);
+    }
+}
+
+static void qxl_worker_save(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_SAVE;
+
+    write_message(dispatcher->channel, &message);
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+}
+
+static void qxl_worker_load(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_LOAD;
+
+    write_message(dispatcher->channel, &message);
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+}
+
+static void qxl_worker_start(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_START;
+
+    write_message(dispatcher->channel, &message);
+}
+
+static void qxl_worker_stop(QXLWorker *qxl_worker)
+{
+    RedDispatcher *dispatcher = (RedDispatcher *)qxl_worker;
+    RedWorkeMessage message = RED_WORKER_MESSAGE_STOP;
+
+    write_message(dispatcher->channel, &message);
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+}
+
+void red_dispatcher_set_mm_time(uint32_t mm_time)
+{
+    RedDispatcher *now = dispatchers;
+    while (now) {
+        now->qxl_interface->set_mm_time(now->qxl_interface, mm_time);
+        now = now->next;
+    }
+}
+
+static inline int calc_compression_level()
+{
+    if (streaming_video || (image_compression != IMAGE_COMPRESS_QUIC)) {
+        return 0;
+    } else {
+        return 1;
+    }
+}
+
+void red_dispatcher_on_ic_change()
+{
+    int compression_level = calc_compression_level();
+    RedDispatcher *now = dispatchers;
+    while (now) {
+        RedWorkeMessage message = RED_WORKER_MESSAGE_SET_COMPRESSION;
+        now->qxl_interface->set_compression_level(now->qxl_interface, compression_level);
+        write_message(now->channel, &message);
+        send_data(now->channel, &image_compression, sizeof(image_compression_t));
+        now = now->next;
+    }
+}
+
+void red_dispatcher_on_sv_change()
+{
+    int compression_level = calc_compression_level();
+    RedDispatcher *now = dispatchers;
+    while (now) {
+        RedWorkeMessage message = RED_WORKER_MESSAGE_SET_STREAMING_VIDEO;
+        now->qxl_interface->set_compression_level(now->qxl_interface, compression_level);
+        write_message(now->channel, &message);
+        send_data(now->channel, &streaming_video, sizeof(uint32_t));
+        now = now->next;
+    }
+}
+
+void red_dispatcher_set_mouse_mode(uint32_t mode)
+{
+    RedDispatcher *now = dispatchers;
+    while (now) {
+        RedWorkeMessage message = RED_WORKER_MESSAGE_SET_MOUSE_MODE;
+        write_message(now->channel, &message);
+        send_data(now->channel, &mode, sizeof(uint32_t));
+        now = now->next;
+    }
+}
+
+int red_dispatcher_count()
+{
+    RedDispatcher *now = dispatchers;
+    int ret = 0;
+
+    while (now) {
+        ret++;
+        now = now->next;
+    }
+    return ret;
+}
+
+uint32_t red_dispatcher_qxl_ram_size()
+{
+    QXLDevInfo qxl_info;
+    dispatchers->qxl_interface->get_info(dispatchers->qxl_interface, &qxl_info);
+    return qxl_info.ram_size;
+}
+
+RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface)
+{
+    RedDispatcher *dispatcher;
+    int channels[2];
+    RedWorkeMessage message;
+    WorkerInitData init_data;
+    int r;
+    Channel *reds_channel;
+    Channel *cursor_channel;
+    sigset_t thread_sig_mask;
+    sigset_t curr_sig_mask;
+
+    if (qxl_interface->pci_vendor != REDHAT_PCI_VENDOR_ID ||
+        qxl_interface->pci_id != QXL_DEVICE_ID ||
+        qxl_interface->pci_revision != QXL_REVISION) {
+        red_printf("pci mismatch");
+        return NULL;
+    }
+
+    quic_init();
+    cairo_canvas_init();
+    gl_canvas_init();
+
+    if (socketpair(AF_LOCAL, SOCK_STREAM, 0, channels) == -1) {
+        red_error("socketpair failed %s", strerror(errno));
+    }
+
+    if (!(dispatcher = malloc(sizeof(RedDispatcher)))) {
+        red_error("malloc failed");
+    }
+    memset(dispatcher, 0, sizeof(RedDispatcher));
+    dispatcher->channel = channels[0];
+    init_data.qxl_interface = dispatcher->qxl_interface = qxl_interface;
+    init_data.id = qxl_interface->base.id;
+    init_data.channel = channels[1];
+    init_data.pending = &dispatcher->pending;
+    init_data.num_renderers = num_renderers;
+    memcpy(init_data.renderers, renderers, sizeof(init_data.renderers));
+
+    init_data.image_compression = image_compression;
+    init_data.streaming_video = streaming_video;
+
+    dispatcher->base.major_version = VD_INTERFACE_QXL_MAJOR;
+    dispatcher->base.major_version = VD_INTERFACE_QXL_MINOR;
+    dispatcher->base.attach = qxl_worker_attach;
+    dispatcher->base.detach = qxl_worker_detach;
+    dispatcher->base.wakeup = qxl_worker_wakeup;
+    dispatcher->base.oom = qxl_worker_oom;
+    dispatcher->base.save = qxl_worker_save;
+    dispatcher->base.load = qxl_worker_load;
+    dispatcher->base.start = qxl_worker_start;
+    dispatcher->base.stop = qxl_worker_stop;
+    dispatcher->base.update_area = qxl_worker_update_area;
+
+    sigfillset(&thread_sig_mask);
+    sigdelset(&thread_sig_mask, SIGILL);
+    sigdelset(&thread_sig_mask, SIGFPE);
+    sigdelset(&thread_sig_mask, SIGSEGV);
+    pthread_sigmask(SIG_SETMASK, &thread_sig_mask, &curr_sig_mask);
+    if ((r = pthread_create(&dispatcher->worker_thread, NULL, red_worker_main, &init_data))) {
+        red_error("create thread failed %d", r);
+    }
+    pthread_sigmask(SIG_SETMASK, &curr_sig_mask, NULL);
+
+    read_message(dispatcher->channel, &message);
+    ASSERT(message == RED_WORKER_MESSAGE_READY);
+    if (!(reds_channel = malloc(sizeof(Channel)))) {
+        red_error("reds channel malloc failed");
+    }
+    memset(reds_channel, 0, sizeof(Channel));
+    reds_channel->type = RED_CHANNEL_DISPLAY;
+    reds_channel->id = qxl_interface->base.id;
+    reds_channel->link = red_dispatcher_set_peer;
+    reds_channel->shutdown = red_dispatcher_shutdown_peer;
+    reds_channel->migrate = red_dispatcher_migrate;
+    reds_channel->data = dispatcher;
+    reds_register_channel(reds_channel);
+
+    if (!(cursor_channel = malloc(sizeof(Channel)))) {
+        red_error("reds channel malloc failed");
+    }
+    memset(cursor_channel, 0, sizeof(Channel));
+    cursor_channel->type = RED_CHANNEL_CURSOR;
+    cursor_channel->id = qxl_interface->base.id;
+    cursor_channel->link = red_dispatcher_set_cursor_peer;
+    cursor_channel->shutdown = red_dispatcher_shutdown_cursor_peer;
+    cursor_channel->migrate = red_dispatcher_cursor_migrate;
+    cursor_channel->data = dispatcher;
+    reds_register_channel(cursor_channel);
+    qxl_interface->attache_worker(qxl_interface, &dispatcher->base);
+    qxl_interface->set_compression_level(qxl_interface, calc_compression_level());
+
+    dispatcher->next = dispatchers;
+    dispatchers = dispatcher;
+    return dispatcher;
+}
+
diff --git a/server/red_dispatcher.h b/server/red_dispatcher.h
new file mode 100644
index 00000000..9482bc46
--- /dev/null
+++ b/server/red_dispatcher.h
@@ -0,0 +1,33 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_RED_DISPATCHER
+#define _H_RED_DISPATCHER
+
+
+struct RedDispatcher *red_dispatcher_init(QXLInterface *qxl_interface);
+
+void red_dispatcher_set_mm_time(uint32_t);
+void red_dispatcher_on_ic_change();
+void red_dispatcher_on_sv_change();
+void red_dispatcher_set_mouse_mode(uint32_t mode);
+int red_dispatcher_count();
+int red_dispatcher_add_renderer(const char *name);
+uint32_t red_dispatcher_qxl_ram_size();
+int red_dispatcher_qxl_count();
+#endif
+
diff --git a/server/red_worker.c b/server/red_worker.c
new file mode 100644
index 00000000..4604e05e
--- /dev/null
+++ b/server/red_worker.c
@@ -0,0 +1,8492 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/epoll.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <netinet/tcp.h>
+#include <setjmp.h>
+#include <openssl/ssl.h>
+
+#include "qxl_dev.h"
+#include "vd_interface.h"
+#include "region.h"
+#include "red.h"
+#include "red_worker.h"
+#include "cairo.h"
+#include "cairo_canvas.h"
+#include "gl_canvas.h"
+#include "ogl_ctx.h"
+#include "libavcodec/avcodec.h"
+#include "quic.h"
+#include "lz.h"
+#include "glz_encoder_dictionary.h"
+#include "glz_encoder.h"
+#include "stat.h"
+#include "reds.h"
+#include "ring.h"
+
+//#define COMPRESS_STAT
+//#define DUMP_BITMAP
+#define STREAM_TRACE
+//#define PIPE_DEBUG
+#define USE_EXCLUDE_RGN
+//#define RED_WORKER_STAT
+//#define DRAW_ALL
+//#define COMPRESS_DEBUG
+
+//#define UPDATE_AREA_BY_TREE
+
+#define CMD_RING_POLL_TIMEOUT 10 //milli
+#define CMD_RING_POLL_RETRIES 200
+
+#define DETACH_TIMEOUT 4000000000 //nano
+#define DETACH_SLEEP_DURATION 10000 //micro
+
+#define DISPLAY_CLIENT_TIMEOUT 4000000000 //nano
+#define DISPLAY_CLIENT_RETRY_INTERVAL 10000 //micro
+#define DISPLAY_MAX_SUB_MESSAGES 10
+
+#define DISPLAY_FREE_LIST_DEFAULT_SIZE 128
+
+#define RED_STREAM_DETACTION_MAX_DELTA ((1000 * 1000 * 1000) / 5) // 1/5 sec
+#define RED_STREAM_CONTINUS_MAX_DELTA ((1000 * 1000 * 1000) / 2) // 1/2 sec
+#define RED_STREAM_TIMOUT (1000 * 1000 * 1000)
+#define RED_STREAM_START_CONDITION 20
+
+#define FPS_TEST_INTERVAL 1
+#define MAX_FPS 30
+
+//best bit rate per pixel base on 13000000 bps for frame size 720x576 pixels and 25 fps
+#define BEST_BIT_RATE_PER_PIXEL 38
+#define WARST_BIT_RATE_PER_PIXEL 4
+
+#define RED_COMPRESS_BUF_SIZE (1024 * 64)
+
+typedef int64_t red_time_t;
+
+static inline red_time_t timespec_to_red_time(struct timespec *time)
+{
+    return time->tv_sec * (1000 * 1000 * 1000) + time->tv_nsec;
+}
+
+#if defined(RED_WORKER_STAT) || defined(COMPRESS_STAT)
+static clockid_t clock_id;
+
+typedef unsigned long stat_time_t;
+
+inline stat_time_t stat_now()
+{
+    struct timespec ts;
+    clock_gettime(clock_id, &ts);
+    return ts.tv_nsec + ts.tv_sec * 1000 * 1000 * 1000;
+}
+
+double stat_cpu_time_to_sec(stat_time_t time)
+{
+    return (double)time / (1000 * 1000 * 1000);
+}
+
+typedef struct stat_info_s {
+    const char *name;
+    uint32_t count;
+    stat_time_t max;
+    stat_time_t min;
+    stat_time_t total;
+#ifdef COMPRESS_STAT
+    uint64_t orig_size;
+    uint64_t comp_size;
+#endif
+} stat_info_t;
+
+static inline void stat_reset(stat_info_t *info)
+{
+    info->count = info->max = info->total = 0;
+    info->min = ~(stat_time_t)0;
+#ifdef COMPRESS_STAT
+    info->orig_size = info->comp_size = 0;
+#endif
+}
+
+#endif
+
+#ifdef RED_WORKER_STAT
+static const char *add_stat_name = "add";
+static const char *exclude_stat_name = "exclude";
+static const char *__exclude_stat_name = "__exclude";
+
+static inline void stat_init(stat_info_t *info, const char *name)
+{
+    info->name = name;
+    stat_reset(info);
+}
+
+static inline void stat_add(stat_info_t *info, stat_time_t start)
+{
+    stat_time_t time;
+    ++info->count;
+    time = stat_now() - start;
+    info->total += time;
+    info->max = MAX(info->max, time);
+    info->min = MIN(info->min, time);
+}
+
+#else
+#define stat_add(a, b)
+#define stat_init(a, b)
+#endif
+
+#ifdef COMPRESS_STAT
+static const char *lz_stat_name = "lz";
+static const char *glz_stat_name = "glz";
+static const char *quic_stat_name = "quic";
+
+static inline void stat_compress_init(stat_info_t *info, const char *name)
+{
+    info->name = name;
+    stat_reset(info);
+}
+
+static inline void stat_compress_add(stat_info_t *info, stat_time_t start, int orig_size,
+                                     int comp_size)
+{
+    stat_time_t time;
+    ++info->count;
+    time = stat_now() - start;
+    info->total += time;
+    info->max = MAX(info->max, time);
+    info->min = MIN(info->min, time);
+    info->orig_size += orig_size;
+    info->comp_size += comp_size;
+}
+
+double inline stat_byte_to_mega(uint64_t size)
+{
+    return (double)size / (1000 * 1000);
+}
+
+#else
+#define stat_compress_init(a, b)
+#define stat_compress_add(a, b, c, d)
+#endif
+
+#define MAX_EPOLL_SOURCES 10
+#define INF_EPOLL_WAIT ~0
+
+
+typedef struct EventListener EventListener;
+typedef void (*event_listener_action_proc)(EventListener *ctx, uint32_t events);
+struct EventListener {
+    uint32_t refs;
+    event_listener_action_proc action;
+};
+
+enum {
+    BUF_TYPE_RAW = 1,
+    BUF_TYPE_COMPRESS_BUF,
+    BUF_TYPE_CHUNK,
+};
+
+typedef struct BufDescriptor {
+    uint32_t type;
+    uint32_t size;
+    uint8_t *data;
+} BufDescriptor;
+
+enum {
+    PIPE_ITEM_TYPE_DRAW,
+    PIPE_ITEM_TYPE_MODE,
+    PIPE_ITEM_TYPE_INVAL_ONE,
+    PIPE_ITEM_TYPE_CURSOR,
+    PIPE_ITEM_TYPE_MIGRATE,
+    PIPE_ITEM_TYPE_LOCAL_CURSOR,
+    PIPE_ITEM_TYPE_SET_ACK,
+    PIPE_ITEM_TYPE_CURSOR_INIT,
+    PIPE_ITEM_TYPE_IMAGE,
+    PIPE_ITEM_TYPE_STREAM_CREATE,
+    PIPE_ITEM_TYPE_STREAM_CLIP,
+    PIPE_ITEM_TYPE_STREAM_DESTROY,
+    PIPE_ITEM_TYPE_UPGRADE,
+    PIPE_ITEM_TYPE_VERB,
+    PIPE_ITEM_TYPE_MIGRATE_DATA,
+    PIPE_ITEM_TYPE_PIXMAP_SYNC,
+    PIPE_ITEM_TYPE_PIXMAP_RESET,
+    PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE,
+    PIPE_ITEM_TYPE_INVAL_PALLET_CACHE,
+};
+
+typedef struct PipeItem {
+    RingItem link;
+    int type;
+} PipeItem;
+
+typedef struct VerbItem {
+    PipeItem base;
+    uint16_t verb;
+} VerbItem;
+
+#define MAX_CACHE_CLIENTS 4
+#define MAX_LZ_ENCODERS MAX_CACHE_CLIENTS
+
+typedef struct NewCacheItem NewCacheItem;
+
+struct NewCacheItem {
+    RingItem lru_link;
+    NewCacheItem *next;
+    uint64_t id;
+    uint64_t sync[MAX_CACHE_CLIENTS];
+    size_t size;
+};
+
+typedef struct CacheItem CacheItem;
+
+struct CacheItem {
+    union {
+        PipeItem pipe_data;
+        struct {
+            RingItem lru_link;
+            CacheItem *next;
+        } cache_data;
+    } u;
+    uint64_t id;
+    size_t size;
+    uint32_t inval_type;
+};
+
+enum {
+    CURSOR_TYPE_INVALID,
+    CURSOR_TYPE_DEV,
+    CURSOR_TYPE_LOCAL,
+};
+
+typedef struct CursorItem {
+    PipeItem pipe_data;
+    int refs;
+    int type;
+} CursorItem;
+
+typedef struct LocalCursor {
+    CursorItem base;
+    Point16 position;
+    uint32_t data_size;
+    RedCursor red_cursor;
+} LocalCursor;
+
+#define MAX_SEND_BUFS 20
+#define MAX_BITMAPS 4
+#define MAX_PIPE_SIZE 50
+#define RECIVE_BUF_SIZE 1024
+
+#define WIDE_CLIENT_ACK_WINDOW 40
+#define NARROW_CLIENT_ACK_WINDOW 20
+
+#define BITS_CACHE_HASH_SHIFT 10
+#define BITS_CACHE_HASH_SIZE (1 << BITS_CACHE_HASH_SHIFT)
+#define BITS_CACHE_HASH_MASK (BITS_CACHE_HASH_SIZE - 1)
+#define BITS_CACHE_HASH_KEY(id) ((id) & BITS_CACHE_HASH_MASK)
+
+#define CLIENT_CURSOR_CACHE_SIZE 256
+
+#define CURSOR_CACHE_HASH_SHIFT 8
+#define CURSOR_CACHE_HASH_SIZE (1 << CURSOR_CACHE_HASH_SHIFT)
+#define CURSOR_CACHE_HASH_MASK (CURSOR_CACHE_HASH_SIZE - 1)
+#define CURSOR_CACHE_HASH_KEY(id) ((id) & CURSOR_CACHE_HASH_MASK)
+
+#define CLIENT_PALETTE_CACHE_SIZE 128
+
+#define PALETTE_CACHE_HASH_SHIFT 8
+#define PALETTE_CACHE_HASH_SIZE (1 << PALETTE_CACHE_HASH_SHIFT)
+#define PALETTE_CACHE_HASH_MASK (PALETTE_CACHE_HASH_SIZE - 1)
+#define PALETTE_CACHE_HASH_KEY(id) ((id) & PALETTE_CACHE_HASH_MASK)
+
+typedef struct RedChannel RedChannel;
+typedef void (*disconnect_channel_proc)(RedChannel *channel);
+typedef void (*hold_item_proc)(void *item);
+typedef void (*release_item_proc)(RedChannel *channel, void *item);
+typedef int (*handle_message_proc)(RedChannel *channel, RedDataHeader *message);
+
+struct RedChannel {
+    EventListener listener;
+    uint32_t id;
+    struct RedWorker *worker;
+    RedsStreamContext *peer;
+    int migrate;
+
+    Ring pipe;
+    uint32_t pipe_size;
+
+    uint32_t client_ack_window;
+    uint32_t ack_generation;
+    uint32_t client_ack_generation;
+    uint32_t messages_window;
+
+    struct {
+        int blocked;
+        RedDataHeader header;
+        union {
+            RedSetAck ack;
+        } u;
+        uint32_t n_bufs;
+        BufDescriptor bufs[MAX_SEND_BUFS];
+        uint32_t size;
+        uint32_t pos;
+        void *item;
+    } send_data;
+
+    struct {
+        uint8_t buf[RECIVE_BUF_SIZE];
+        RedDataHeader *message;
+        uint8_t *now;
+        uint8_t *end;
+    } recive_data;
+
+    disconnect_channel_proc disconnect;
+    hold_item_proc hold_item;
+    release_item_proc release_item;
+    handle_message_proc handle_message;
+#ifdef RED_STATISTICS
+    uint64_t *out_bytes_counter;
+#endif
+};
+
+typedef struct ImageItem {
+    PipeItem link;
+    int refs;
+    Point pos;
+    int width;
+    int height;
+    int stride;
+    int top_down;
+    uint8_t data[0];
+} ImageItem;
+
+typedef struct Drawable Drawable;
+
+typedef struct Stream Stream;
+struct Stream {
+    uint8_t refs;
+    Drawable *current;
+#ifdef STREAM_TRACE
+    red_time_t last_time;
+    int width;
+    int height;
+    Rect dest_area;
+#endif
+    int top_down;
+    Stream *next;
+    RingItem link;
+    AVCodecContext *av_ctx;
+    AVFrame *av_frame;
+    uint8_t* frame_buf;
+    uint8_t* frame_buf_end;
+    int bit_rate;
+};
+
+typedef struct StreamAgent {
+    QRegion vis_region;
+    PipeItem create_item;
+    PipeItem destroy_item;
+    Stream *stream;
+    uint64_t lats_send_time;
+
+    int frames;
+    int drops;
+    int fps;
+} StreamAgent;
+
+typedef struct StreamClipItem {
+    PipeItem base;
+    int refs;
+    StreamAgent *stream_agent;
+    int clip_type;
+    QRegion region;
+} StreamClipItem;
+
+typedef struct RedCompressBuf RedCompressBuf;
+struct RedCompressBuf {
+    uint32_t buf[RED_COMPRESS_BUF_SIZE / 4];
+    RedCompressBuf *next;
+    RedCompressBuf *send_next;
+};
+
+static const int BITMAP_FMT_IS_PLT[] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0};
+static const int BITMAP_FMT_IS_RGB[] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
+static const int BITMAP_FMP_BYTES_PER_PIXEL[] = {0, 0, 0, 0, 0, 1, 2, 3, 4, 4};
+
+typedef struct  __attribute__ ((__packed__)) RedImage {
+    ImageDescriptor descriptor;
+    union { // variable length
+        Bitmap bitmap;
+        QUICData quic;
+        LZ_RGBData lz_rgb;
+        LZ_PLTData lz_plt;
+    };
+} RedImage;
+
+pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
+Ring pixmap_cache_list = {&pixmap_cache_list, &pixmap_cache_list};
+
+typedef struct PixmapCache PixmapCache;
+struct PixmapCache {
+    RingItem base;
+    pthread_mutex_t lock;
+    uint8_t id;
+    uint32_t refs;
+    NewCacheItem *hash_table[BITS_CACHE_HASH_SIZE];
+    Ring lru;
+    int64_t available;
+    int64_t size;
+    int32_t items;
+
+    int freezed;
+    RingItem *freezed_head;
+    RingItem *freezed_tail;
+
+    uint32_t generation;
+    struct {
+        uint8_t client;
+        uint64_t message;
+    } generation_initiator;
+    uint64_t sync[MAX_CACHE_CLIENTS];
+};
+
+#define NUM_STREAMS 50
+
+#define DISPLAY_MIGRATE_DATA_MAGIC (*(uint32_t*)"DMDA")
+#define DISPLAY_MIGRATE_DATA_VERSION 2
+
+typedef struct __attribute__ ((__packed__)) DisplayChannelMigrateData {
+    //todo: add ack_generation + move common to generic migration data
+    uint32_t magic;
+    uint32_t version;
+    uint64_t message_serial;
+
+    uint8_t pixmap_cache_freezer;
+    uint8_t pixmap_cache_id;
+    int64_t pixmap_cache_size;
+    uint64_t pixmap_cache_clients[MAX_CACHE_CLIENTS];
+
+    uint8_t glz_dict_id;
+    GlzEncDictRestoreData glz_dict_restore_data;
+} DisplayChannelMigrateData;
+
+typedef struct WaitForChannels {
+    RedWaitForChannels header;
+    RedWaitForChannel buf[MAX_CACHE_CLIENTS];
+} WaitForChannels;
+
+typedef struct FreeList {
+    int res_size;
+    RedResorceList *res;
+    uint64_t sync[MAX_CACHE_CLIENTS];
+    WaitForChannels wait;
+} FreeList;
+
+typedef struct DisplayChannel DisplayChannel;
+
+typedef struct  {
+    DisplayChannel *display_channel;
+    RedCompressBuf *bufs_head;
+    RedCompressBuf *bufs_tail;
+    jmp_buf jmp_env;
+    union {
+        struct {
+            ADDRESS next;
+            long address_delta;
+            uint32_t stride;
+        } lines_data;
+        struct {
+            uint8_t* next;
+            int src_stride;
+            uint32_t dest_stride;
+            int lines;
+            int max_lines_bunch;
+            int input_bufs_pos;
+            RedCompressBuf *input_bufs[2];
+        } unstable_lines_data;
+    } u;
+    char message_buf[512];
+} EncoderData;
+
+typedef struct {
+    QuicUsrContext usr;
+    EncoderData data;
+} QuicData;
+
+typedef struct {
+    LzUsrContext usr;
+    EncoderData data;
+} LzData;
+
+typedef struct {
+    GlzEncoderUsrContext usr;
+    EncoderData data;
+} GlzData;
+
+/**********************************/
+/* LZ dictionary related entities */
+/**********************************/
+#define MAX_GLZ_DRAWABLE_INSTANCES 2
+
+typedef struct RedGlzDrawable RedGlzDrawable;
+
+/* for each qxl drawable, there may be serveral instances of lz drawables */
+typedef struct GlzDrawableInstanceItem {
+    RingItem glz_link;
+    RingItem free_link;
+    GlzEncDictImageContext *glz_instance;
+    RedGlzDrawable         *red_glz_drawable;
+} GlzDrawableInstanceItem;
+
+struct RedGlzDrawable {
+    RingItem link;    // ordered by the time it was encoded
+    QXLDrawable *qxl_drawable;
+    Drawable    *drawable;
+    GlzDrawableInstanceItem instances_pool[MAX_GLZ_DRAWABLE_INSTANCES];
+    Ring instances;
+    uint8_t instances_count;
+    DisplayChannel *display_channel;
+};
+
+pthread_mutex_t glz_dictionary_list_lock = PTHREAD_MUTEX_INITIALIZER;
+Ring glz_dictionary_list = {&glz_dictionary_list, &glz_dictionary_list};
+
+typedef struct GlzSharedDictionary {
+    RingItem base;
+    GlzEncDictContext *dict;
+    uint32_t refs;
+    uint8_t id;
+    pthread_rwlock_t encode_lock;
+    int migrate_freeze;
+} GlzSharedDictionary;
+
+struct DisplayChannel {
+    RedChannel base;
+
+    int expect_init;
+    int expect_migrate_mark;
+    int expect_migrate_data;
+
+    PixmapCache *pixmap_cache;
+    uint32_t pixmap_cache_generation;
+    int pending_pixmaps_sync;
+
+    CacheItem *palette_cache[PALETTE_CACHE_HASH_SIZE];
+    Ring palette_cache_lru;
+    long palette_cache_available;
+    uint32_t palette_cache_items;
+
+    StreamAgent stream_agents[NUM_STREAMS];
+
+    /* global lz encoding entities */
+    GlzSharedDictionary *glz_dict;
+    GlzEncoderContext   *glz;
+    GlzData glz_data;
+
+    Ring glz_drawables;               // all the living lz drawable, ordered by encoding time
+    Ring glz_drawables_inst_to_free;               // list of instances to be freed
+    pthread_mutex_t glz_drawables_inst_to_free_lock;
+
+    struct {
+        union {
+            RedFill fill;
+            RedOpaque opaque;
+            RedCopy copy;
+            RedTransparent transparent;
+            RedAlphaBlend alpha_blend;
+            RedCopyBits copy_bits;
+            RedBlend blend;
+            RedRop3 rop3;
+            RedBlackness blackness;
+            RedWhiteness whiteness;
+            RedInvers invers;
+            RedStroke stroke;
+            RedText text;
+            RedMode mode;
+            RedInvalOne inval_one;
+            WaitForChannels wait;
+            struct {
+                RedStreamCreate message;
+                uint32_t num_rects;
+            } stream_create;
+            RedStreamClip stream_clip;
+            RedStreamData stream_data;
+            RedStreamDestroy stream_destroy;
+            RedMigrate migrate;
+            DisplayChannelMigrateData migrate_data;
+        } u;
+
+        uint32_t bitmap_pos;
+        RedImage images[MAX_BITMAPS];
+
+        uint32_t stream_outbuf_size;
+        uint8_t *stream_outbuf; // caution stream buffer is also used as compress bufs!!!
+
+        RedCompressBuf *free_compress_bufs;
+        RedCompressBuf *used_compress_bufs;
+
+        struct {
+            RedSubMessageList sub_list;
+            uint32_t sub_messages[DISPLAY_MAX_SUB_MESSAGES];
+        } sub_list;
+        RedSubMessage sub_header[DISPLAY_MAX_SUB_MESSAGES];
+
+        FreeList free_list;
+    } send_data;
+
+#ifdef RED_STATISTICS
+    StatNodeRef stat;
+    uint64_t *cache_hits_counter;
+    uint64_t *add_to_cache_counter;
+    uint64_t *non_cache_counter;
+#endif
+#ifdef COMPRESS_STAT
+    stat_info_t lz_stat;
+    stat_info_t glz_stat;
+    stat_info_t quic_stat;
+#endif
+};
+
+typedef struct CursorChannel {
+    RedChannel base;
+
+    CacheItem *cursor_cache[CURSOR_CACHE_HASH_SIZE];
+    Ring cursor_cache_lru;
+    long cursor_cache_available;
+    uint32_t cursor_cache_items;
+
+    struct {
+        union {
+            RedCursorInit cursor_init;
+            RedCursorSet cursor_set;
+            RedCursorMove cursor_move;
+            RedCursorTrail cursor_trail;
+            RedInvalOne inval_one;
+            RedMigrate migrate;
+        } u;
+    } send_data;
+#ifdef RED_STATISTICS
+    StatNodeRef stat;
+#endif
+} CursorChannel;
+
+typedef struct __attribute__ ((__packed__)) LocalImage {
+    QXLImage qxl_image;
+    uint8_t buf[sizeof(QXLDataChunk *)]; // quic data area
+} LocalImage;
+
+typedef struct ImageCacheItem {
+    RingItem lru_link;
+    uint64_t id;
+#ifdef IMAGE_CACHE_AGE
+    uint32_t age;
+#endif
+    struct ImageCacheItem *next;
+    cairo_surface_t *surf;
+} ImageCacheItem;
+
+#define IMAGE_CACHE_HASH_SIZE 1024
+
+typedef struct ImageCache {
+    ImageCacheItem *hash_table[IMAGE_CACHE_HASH_SIZE];
+    Ring lru;
+#ifdef IMAGE_CACHE_AGE
+    uint32_t age;
+#else
+    uint32_t num_items;
+#endif
+} ImageCache;
+
+enum {
+    TREE_ITEM_TYPE_DRAWABLE,
+    TREE_ITEM_TYPE_CONTAINER,
+    TREE_ITEM_TYPE_SHADOW,
+};
+
+typedef struct TreeItem {
+    RingItem siblings_link;
+    uint32_t type;
+    struct Container *container;
+    QRegion rgn;
+#ifdef PIPE_DEBUG
+    uint32_t id;
+#endif
+} TreeItem;
+
+#define IS_DRAW_ITEM(item) ((item)->type == TREE_ITEM_TYPE_DRAWABLE)
+
+typedef struct Shadow {
+    TreeItem base;
+    QRegion on_hold;
+    struct DrawItem* owner;
+} Shadow;
+
+typedef struct Container {
+    TreeItem base;
+    Ring items;
+} Container;
+
+typedef struct DrawItem {
+    TreeItem base;
+    uint8_t effect;
+    uint8_t container_root;
+    Shadow *shadow;
+} DrawItem;
+
+struct Drawable {
+    uint8_t refs;
+    RingItem list_link;
+    DrawItem tree_item;
+    PipeItem pipe_item;
+#ifdef UPDATE_AREA_BY_TREE
+    RingItem collect_link;
+#endif
+    QXLDrawable *qxl_drawable;
+
+    RedGlzDrawable *red_glz_drawable;
+
+    red_time_t creation_time;
+    int frames_count;
+    Stream *stream;
+#ifdef STREAM_TRACE
+    int streamable;
+#endif
+};
+
+typedef struct _Drawable _Drawable;
+struct _Drawable {
+    union {
+        Drawable drawable;
+        _Drawable *next;
+    } u;
+};
+
+typedef struct UpgradeItem {
+    PipeItem base;
+    int refs;
+    Drawable *drawable;
+    QRegion region;
+} UpgradeItem;
+
+typedef void (*set_access_params_t)(void *canvas, ADDRESS delta);
+typedef void (*draw_fill_t)(void *canvas, Rect *bbox, Clip *clip, Fill *fill);
+typedef void (*draw_copy_t)(void *canvas, Rect *bbox, Clip *clip, Copy *copy);
+typedef void (*draw_opaque_t)(void *canvas, Rect *bbox, Clip *clip, Opaque *opaque);
+typedef void (*copy_bits_t)(void *canvas, Rect *bbox, Clip *clip, Point *src_pos);
+typedef void (*draw_text_t)(void *canvas, Rect *bbox, Clip *clip, Text *text);
+typedef void (*draw_stroke_t)(void *canvas, Rect *bbox, Clip *clip, Stroke *stroke);
+typedef void (*draw_rop3_t)(void *canvas, Rect *bbox, Clip *clip, Rop3 *rop3);
+typedef void (*draw_blend_t)(void *canvas, Rect *bbox, Clip *clip, Blend *blend);
+typedef void (*draw_blackness_t)(void *canvas, Rect *bbox, Clip *clip, Blackness *blackness);
+typedef void (*draw_whiteness_t)(void *canvas, Rect *bbox, Clip *clip, Whiteness *whiteness);
+typedef void (*draw_invers_t)(void *canvas, Rect *bbox, Clip *clip, Invers *invers);
+typedef void (*draw_transparent_t)(void *canvas, Rect *bbox, Clip *clip, Transparent* transparent);
+typedef void (*draw_alpha_blend_t)(void *canvas, Rect *bbox, Clip *clip, AlphaBlnd* alpha_blend);
+typedef void (*read_pixels_t)(void *canvas, uint8_t *dest, int dest_stride, const Rect *area);
+typedef void (*set_top_mask_t)(void *canvas, int num_rect, const Rect *rects);
+typedef void (*clear_top_mask_t)(void *canvas);
+typedef void (*validate_area_t)(void *canvas, const DrawArea *draw_area, const Rect *area);
+typedef void (*destroy_t)(void *canvas);
+
+
+typedef struct DrawContext {
+    void *canvas;
+    int top_down;
+    set_access_params_t set_access_params;
+    draw_fill_t draw_fill;
+    draw_copy_t draw_copy;
+    draw_opaque_t draw_opaque;
+    copy_bits_t copy_bits;
+    draw_text_t draw_text;
+    draw_stroke_t draw_stroke;
+    draw_rop3_t draw_rop3;
+    draw_blend_t draw_blend;
+    draw_blackness_t draw_blackness;
+    draw_whiteness_t draw_whiteness;
+    draw_invers_t draw_invers;
+    draw_transparent_t draw_transparent;
+    draw_alpha_blend_t draw_alpha_blend;
+    read_pixels_t read_pixels;
+    set_top_mask_t set_top_mask;
+    clear_top_mask_t clear_top_mask;
+    validate_area_t validate_area;
+    destroy_t destroy;
+} DrawContext;
+
+
+#ifdef STREAM_TRACE
+typedef struct ItemTrace {
+    red_time_t time;
+    int frames_count;
+    int width;
+    int height;
+    Rect dest_area;
+} ItemTrace;
+
+#define TRACE_ITEMS_SHIFT 3
+#define NUM_TRACE_ITEMS (1 << TRACE_ITEMS_SHIFT)
+#define ITEMS_TRACE_MASK (NUM_TRACE_ITEMS - 1)
+
+#endif
+
+#define NUM_DRAWABLES 1000
+
+typedef struct RedWorker {
+    EventListener dev_listener;
+    DisplayChannel *display_channel;
+    CursorChannel *cursor_channel;
+    QXLInterface *qxl;
+    int id;
+    int channel;
+    int attached;
+    int running;
+    uint32_t *pending;
+    QXLDevInfo dev_info;
+    int epoll;
+    unsigned int epoll_timeout;
+    uint32_t repoll_cmd_ring;
+    uint32_t repoll_cursor_ring;
+    DrawContext draw_context;
+    uint32_t num_renderers;
+    uint32_t renderers[RED_MAX_RENDERERS];
+
+    Ring current_list;
+    Ring current;
+    uint32_t current_size;
+    uint32_t drawable_count;
+    uint32_t transparent_count;
+
+    uint32_t shadows_count;
+    uint32_t containers_count;
+
+    uint32_t bits_unique;
+
+    CursorItem *cursor;
+    int cursor_visible;
+    Point16 cursor_position;
+    uint16_t cursor_trail_length;
+    uint16_t cursor_trail_frequency;
+
+    _Drawable drawables[NUM_DRAWABLES];
+    _Drawable *free_drawables;
+
+    uint32_t local_images_pos;
+    LocalImage local_images[MAX_BITMAPS];
+
+    ImageCache image_cache;
+
+    image_compression_t image_compression;
+
+    uint32_t mouse_mode;
+
+    uint32_t streaming_video;
+    Stream streams_buf[NUM_STREAMS];
+    Stream *free_streams;
+    Ring streams;
+#ifdef STREAM_TRACE
+    ItemTrace items_trace[NUM_TRACE_ITEMS];
+    uint32_t next_item_trace;
+#endif
+
+    QuicData quic_data;
+    QuicContext *quic;
+
+    LzData lz_data;
+    LzContext  *lz;
+
+#ifdef PIPE_DEBUG
+    uint32_t last_id;
+#endif
+#ifdef RED_WORKER_STAT
+    stat_info_t add_stat;
+    stat_info_t exclude_stat;
+    stat_info_t __exclude_stat;
+    uint32_t add_count;
+    uint32_t add_with_shadow_count;
+#endif
+#ifdef RED_STATISTICS
+    StatNodeRef stat;
+    uint64_t *wakeup_counter;
+    uint64_t *command_counter;
+#endif
+} RedWorker;
+
+pthread_mutex_t avcodec_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static void red_draw_qxl_drawable(RedWorker *worker, QXLDrawable *drawable);
+static void red_current_flush(RedWorker *worker);
+static void display_channel_push(RedWorker *worker);
+#ifdef DRAW_ALL
+#define red_update_area(worker, rect)
+#define red_draw_drawable(worker, item)
+#else
+static void red_draw_drawable(RedWorker *worker, Drawable *item);
+static void red_update_area(RedWorker *worker, const Rect *area);
+#endif
+static void red_release_cursor(RedWorker *worker, CursorItem *cursor);
+static inline void release_drawable(RedWorker *worker, Drawable *item);
+static void red_display_release_stream(DisplayChannel *display, StreamAgent *agent);
+#ifdef STREAM_TRACE
+static inline void red_detach_stream(RedWorker *worker, Stream *stream);
+#endif
+static void red_stop_stream(RedWorker *worker, Stream *stream);
+static inline void red_stream_maintenance(RedWorker *worker, Drawable *candidate, Drawable *sect);
+static inline void red_begin_send_massage(RedChannel *channel, void *item);
+static inline void display_begin_send_massage(DisplayChannel *channel, void *item);
+static void red_receive(RedChannel *channel);
+static void red_release_pixmap_cache(DisplayChannel *channel);
+static void red_release_glz(DisplayChannel *channel);
+static void red_freeze_glz(DisplayChannel *channel);
+static void display_channel_push_release(DisplayChannel *channel, uint8_t type, uint64_t id,
+                                         uint64_t* sync_data);
+static void red_display_release_stream_clip(DisplayChannel* channel, StreamClipItem *item);
+static int red_display_free_some_independent_glz_drawables(DisplayChannel *channel);
+static void red_display_free_glz_drawable(DisplayChannel *channel, RedGlzDrawable *drawable);
+static void reset_rate(StreamAgent *stream_agent);
+
+#ifdef DUMP_BITMAP
+static void dump_bitmap(RedWorker *worker, Bitmap *bitmap);
+#endif
+
+#ifdef COMPRESS_STAT
+static void print_compress_stats(DisplayChannel *display_channel)
+{
+    if (!display_channel) {
+        return;
+    }
+    red_printf("==> Compression stats for display %u", display_channel->base.id);
+    red_printf("Method   \t  count  \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
+    red_printf("QUIC     \t%8d\t%13.2f\t%12.2f\t%12.2f",
+               display_channel->quic_stat.count,
+               stat_byte_to_mega(display_channel->quic_stat.orig_size),
+               stat_byte_to_mega(display_channel->quic_stat.comp_size),
+               stat_cpu_time_to_sec(display_channel->quic_stat.total)
+               );
+    red_printf("GLZ      \t%8d\t%13.2f\t%12.2f\t%12.2f",
+               display_channel->glz_stat.count,
+               stat_byte_to_mega(display_channel->glz_stat.orig_size),
+               stat_byte_to_mega(display_channel->glz_stat.comp_size),
+               stat_cpu_time_to_sec(display_channel->glz_stat.total)
+               );
+    red_printf("LZ       \t%8d\t%13.2f\t%12.2f\t%12.2f",
+               display_channel->lz_stat.count,
+               stat_byte_to_mega(display_channel->lz_stat.orig_size),
+               stat_byte_to_mega(display_channel->lz_stat.comp_size),
+               stat_cpu_time_to_sec(display_channel->lz_stat.total)
+               );
+    red_printf("-------------------------------------------------------------------");
+    red_printf("Total    \t%8d\t%13.2f\t%12.2f\t%12.2f",
+               display_channel->lz_stat.count + display_channel->glz_stat.count +
+                                                display_channel->quic_stat.count,
+               stat_byte_to_mega(display_channel->lz_stat.orig_size +
+                                 display_channel->glz_stat.orig_size +
+                                 display_channel->quic_stat.orig_size),
+               stat_byte_to_mega(display_channel->lz_stat.comp_size +
+                                 display_channel->glz_stat.comp_size +
+                                 display_channel->quic_stat.comp_size),
+               stat_cpu_time_to_sec(display_channel->lz_stat.total +
+                                    display_channel->glz_stat.total +
+                                    display_channel->quic_stat.total)
+               );
+}
+
+#endif
+
+char *draw_type_to_str(UINT8 type)
+{
+    switch (type) {
+    case QXL_DRAW_FILL:
+        return "QXL_DRAW_FILL";
+    case QXL_DRAW_OPAQUE:
+        return "QXL_DRAW_OPAQUE";
+    case QXL_DRAW_COPY:
+        return "QXL_DRAW_COPY";
+    case QXL_DRAW_TRANSPARENT:
+        return "QXL_DRAW_TRANSPARENT";
+    case QXL_DRAW_ALPHA_BLEND:
+        return "QXL_DRAW_ALPHA_BLEND";
+    case QXL_COPY_BITS:
+        return "QXL_COPY_BITS";
+    case QXL_DRAW_BLEND:
+        return "QXL_DRAW_BLEND";
+    case QXL_DRAW_BLACKNESS:
+        return "QXL_DRAW_BLACKNESS";
+    case QXL_DRAW_WHITENESS:
+        return "QXL_DRAW_WHITENESS";
+    case QXL_DRAW_INVERS:
+        return "QXL_DRAW_INVERS";
+    case QXL_DRAW_ROP3:
+        return "QXL_DRAW_ROP3";
+    case QXL_DRAW_STROKE:
+        return "QXL_DRAW_STROKE";
+    case QXL_DRAW_TEXT:
+        return "QXL_DRAW_TEXT";
+    default:
+        return "?";
+    }
+}
+
+static void show_qxl_drawable(RedWorker *worker, QXLDrawable *drawable, const char *prefix)
+{
+    if (prefix) {
+        printf("%s: ", prefix);
+    }
+
+    printf("%s effect %d bbox(%d %d %d %d)",
+           draw_type_to_str(drawable->type),
+           drawable->effect,
+           drawable->bbox.top,
+           drawable->bbox.left,
+           drawable->bbox.bottom,
+           drawable->bbox.right);
+
+    switch (drawable->type) {
+    case QXL_DRAW_FILL:
+    case QXL_DRAW_OPAQUE:
+    case QXL_DRAW_COPY:
+    case QXL_DRAW_TRANSPARENT:
+    case QXL_DRAW_ALPHA_BLEND:
+    case QXL_COPY_BITS:
+    case QXL_DRAW_BLEND:
+    case QXL_DRAW_BLACKNESS:
+    case QXL_DRAW_WHITENESS:
+    case QXL_DRAW_INVERS:
+    case QXL_DRAW_ROP3:
+    case QXL_DRAW_STROKE:
+    case QXL_DRAW_TEXT:
+        break;
+    default:
+        red_error("bad rawable type");
+    }
+    printf("\n");
+}
+
+static void show_draw_item(RedWorker *worker, DrawItem *draw_item, const char *prefix)
+{
+    if (prefix) {
+        printf("%s: ", prefix);
+    }
+    printf("effect %d bbox(%d %d %d %d)\n",
+           draw_item->effect,
+           draw_item->base.rgn.bbox.top,
+           draw_item->base.rgn.bbox.left,
+           draw_item->base.rgn.bbox.bottom,
+           draw_item->base.rgn.bbox.right);
+}
+
+static inline void red_pipe_item_init(PipeItem *item, int type)
+{
+    ring_item_init(&item->link);
+    item->type = type;
+}
+
+static inline void red_pipe_add(RedChannel *channel, PipeItem *item)
+{
+    ASSERT(channel);
+    channel->pipe_size++;
+    ring_add(&channel->pipe, &item->link);
+}
+
+static inline void red_pipe_add_after(RedChannel *channel, PipeItem *item, PipeItem *pos)
+{
+    ASSERT(channel && pos);
+    channel->pipe_size++;
+    ring_add_after(&item->link, &pos->link);
+}
+
+static inline int pipe_item_is_linked(PipeItem *item)
+{
+    return ring_item_is_linked(&item->link);
+}
+
+static inline void pipe_item_remove(PipeItem *item)
+{
+    ring_remove(&item->link);
+}
+
+static inline void red_pipe_add_tail(RedChannel *channel, PipeItem *item)
+{
+    ASSERT(channel);
+    channel->pipe_size++;
+    ring_add_before(&item->link, &channel->pipe);
+}
+
+static void red_pipe_add_verb(RedChannel* channel, uint16_t verb)
+{
+    VerbItem *item = malloc(sizeof(*item));
+    if (!item) {
+        PANIC("malloc failed");
+    }
+    red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
+    item->verb = verb;
+    red_pipe_add(channel, &item->base);
+}
+
+static void red_pipe_add_type(RedChannel* channel, int pipe_item_type)
+{
+    PipeItem *item = malloc(sizeof(*item));
+    if (!item) {
+        PANIC("malloc failed");
+    }
+    red_pipe_item_init(item, pipe_item_type);
+    red_pipe_add(channel, item);
+}
+
+static inline void red_pipe_add_drawable(RedWorker *worker, Drawable *drawable)
+{
+    if (!worker->display_channel) {
+        return;
+    }
+    drawable->refs++;
+    red_pipe_add(&worker->display_channel->base, &drawable->pipe_item);
+}
+
+static inline void red_pipe_add_drawable_after(RedWorker *worker, Drawable *drawable,
+                                               Drawable *pos_after)
+{
+    if (!worker->display_channel) {
+        return;
+    }
+
+    if (!pos_after || !pipe_item_is_linked(&pos_after->pipe_item)) {
+        red_pipe_add_drawable(worker, drawable);
+        return;
+    }
+    drawable->refs++;
+    red_pipe_add_after(&worker->display_channel->base, &drawable->pipe_item, &pos_after->pipe_item);
+}
+
+static inline void red_pipe_remove_drawable(RedWorker *worker, Drawable *drawable)
+{
+    if (ring_item_is_linked(&drawable->pipe_item.link)) {
+        worker->display_channel->base.pipe_size--;
+        ring_remove(&drawable->pipe_item.link);
+        release_drawable(worker, drawable);
+    }
+}
+
+static inline void red_pipe_add_image_item(RedWorker *worker, ImageItem *item)
+{
+    if (!worker->display_channel) {
+        return;
+    }
+    item->refs++;
+    red_pipe_add(&worker->display_channel->base, &item->link);
+}
+
+static inline uint64_t channel_message_serial(RedChannel *channel)
+{
+    return channel->send_data.header.serial;
+}
+
+static void release_image_item(ImageItem *item)
+{
+    if (!--item->refs) {
+        free(item);
+    }
+}
+
+static void release_upgrade_item(RedWorker* worker, UpgradeItem *item)
+{
+    if (!--item->refs) {
+        release_drawable(worker, item->drawable);
+        region_destroy(&item->region);
+        free(item);
+    }
+}
+
+static void red_pipe_clear(RedChannel *channel)
+{
+    PipeItem *item;
+
+    ASSERT(channel);
+    while ((item = (PipeItem *)ring_get_head(&channel->pipe))) {
+        ring_remove(&item->link);
+        switch (item->type) {
+        case PIPE_ITEM_TYPE_DRAW:
+            release_drawable(channel->worker, CONTAINEROF(item, Drawable, pipe_item));
+            break;
+        case PIPE_ITEM_TYPE_CURSOR:
+            red_release_cursor(channel->worker, (CursorItem *)item);
+            break;
+        case PIPE_ITEM_TYPE_UPGRADE:
+            release_upgrade_item(channel->worker, (UpgradeItem *)item);
+            break;
+        case PIPE_ITEM_TYPE_PIXMAP_RESET:
+        case PIPE_ITEM_TYPE_PIXMAP_SYNC:
+        case PIPE_ITEM_TYPE_INVAL_ONE:
+        case PIPE_ITEM_TYPE_MODE:
+        case PIPE_ITEM_TYPE_MIGRATE:
+        case PIPE_ITEM_TYPE_SET_ACK:
+        case PIPE_ITEM_TYPE_CURSOR_INIT:
+        case PIPE_ITEM_TYPE_VERB:
+        case PIPE_ITEM_TYPE_MIGRATE_DATA:
+        case PIPE_ITEM_TYPE_INVAL_PALLET_CACHE:
+        case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+            free(item);
+            break;
+        case PIPE_ITEM_TYPE_IMAGE:
+            release_image_item((ImageItem *)item);
+            break;
+        case PIPE_ITEM_TYPE_STREAM_CREATE:
+            red_display_release_stream((DisplayChannel *)channel,
+                                       CONTAINEROF(item, StreamAgent, create_item));
+            break;
+        case PIPE_ITEM_TYPE_STREAM_CLIP:
+            red_display_release_stream_clip((DisplayChannel *)channel, (StreamClipItem*)item);
+            break;
+        case PIPE_ITEM_TYPE_STREAM_DESTROY:
+            red_display_release_stream((DisplayChannel *)channel,
+                                       CONTAINEROF(item, StreamAgent, destroy_item));
+            break;
+        }
+    }
+    channel->pipe_size = 0;
+}
+
+#define CLIENT_PIXMAPS_CACHE
+#include "red_client_shared_cache.h"
+#undef CLIENT_PIXMAPS_CACHE
+
+#define CLIENT_CURSOR_CACHE
+#include "red_client_cache.h"
+#undef CLIENT_CURSOR_CACHE
+
+#define CLIENT_PALETTE_CACHE
+#include "red_client_cache.h"
+#undef CLIENT_PALETTE_CACHE
+
+static void red_reset_palette_cache(DisplayChannel *display_channel)
+{
+    red_palette_cache_reset(display_channel, CLIENT_PALETTE_CACHE_SIZE);
+}
+
+static void red_reset_cursor_cache(CursorChannel *channel)
+{
+    red_cursor_cache_reset(channel, CLIENT_CURSOR_CACHE_SIZE);
+}
+
+static inline Drawable *alloc_drawable(RedWorker *worker)
+{
+    Drawable *drawable;
+    if (!worker->free_drawables) {
+        return NULL;
+    }
+    drawable = &worker->free_drawables->u.drawable;
+    worker->free_drawables = worker->free_drawables->u.next;
+    return drawable;
+}
+
+static inline void free_drawable(RedWorker *worker, Drawable *item)
+{
+    ((_Drawable *)item)->u.next = worker->free_drawables;
+    worker->free_drawables = (_Drawable *)item;
+}
+
+static void drawables_init(RedWorker *worker)
+{
+    int i;
+
+    worker->free_drawables = NULL;
+    for (i = 0; i < NUM_DRAWABLES; i++) {
+        free_drawable(worker, &worker->drawables[i].u.drawable);
+    }
+}
+
+static inline void free_qxl_drawable(RedWorker *worker, QXLDrawable *drawable)
+{
+    if (drawable->bitmap_offset) {
+        PHYSICAL *addr = (PHYSICAL *)((uint8_t *)drawable + drawable->bitmap_offset);
+        if (*addr) {
+            free((uint8_t *)*addr + worker->dev_info.phys_delta);
+        }
+    }
+    worker->qxl->release_resource(worker->qxl, &drawable->release_info);
+}
+
+static inline void release_drawable(RedWorker *worker, Drawable *item)
+{
+    if (!--item->refs) {
+#ifdef STREAM_TRACE
+        ASSERT(!item->stream);
+#else
+        if (item->stream) {
+            red_stop_stream(worker, item->stream);
+        }
+#endif
+        ASSERT(!item->tree_item.shadow);
+        region_destroy(&item->tree_item.base.rgn);
+
+        if (item->red_glz_drawable) {
+            item->red_glz_drawable->drawable = NULL;
+        } else { // no refernce to the qxl drawable left
+            free_qxl_drawable(worker, item->qxl_drawable);
+        }
+        free_drawable(worker, item);
+    }
+}
+
+static inline void remove_shadow(RedWorker *worker, DrawItem *item)
+{
+    Shadow *shadow;
+
+    if (!item->shadow) {
+        return;
+    }
+    shadow = item->shadow;
+    item->shadow = NULL;
+    ring_remove(&shadow->base.siblings_link);
+    region_destroy(&shadow->base.rgn);
+    region_destroy(&shadow->on_hold);
+    free(shadow);
+    worker->shadows_count--;
+}
+
+static inline void current_remove_container(RedWorker *worker, Container *container)
+{
+    ASSERT(ring_is_empty(&container->items));
+    worker->containers_count--;
+    ring_remove(&container->base.siblings_link);
+    region_destroy(&container->base.rgn);
+    free(container);
+}
+
+static inline void container_cleanup(RedWorker *worker, Container *container)
+{
+    while (container && container->items.next == container->items.prev) {
+        Container *next = container->base.container;
+        if (container->items.next != &container->items) {
+            TreeItem *item = (TreeItem *)ring_get_head(&container->items);
+            ASSERT(item);
+            ring_remove(&item->siblings_link);
+            ring_add_after(&item->siblings_link, &container->base.siblings_link);
+            item->container = container->base.container;
+        }
+        current_remove_container(worker, container);
+        container = next;
+    }
+}
+
+#ifdef STREAM_TRACE
+static inline void red_add_item_trace(RedWorker *worker, Drawable *item)
+{
+    ItemTrace *trace;
+    if (!item->streamable) {
+        return;
+    }
+
+    trace = &worker->items_trace[worker->next_item_trace++ & ITEMS_TRACE_MASK];
+    trace->time = item->creation_time;
+    trace->frames_count = item->frames_count;
+    Rect* src_area = &item->qxl_drawable->u.copy.src_area;
+    trace->width = src_area->right - src_area->left;
+    trace->height = src_area->bottom - src_area->top;
+    trace->dest_area = item->qxl_drawable->bbox;
+}
+
+#endif
+
+static inline void current_remove_drawable(RedWorker *worker, Drawable *item)
+{
+    worker->drawable_count--;
+    if (item->tree_item.effect != QXL_EFFECT_OPAQUE) {
+        worker->transparent_count--;
+    }
+#ifdef STREAM_TRACE
+    if (item->stream) {
+        red_detach_stream(worker, item->stream);
+    } else {
+        red_add_item_trace(worker, item);
+    }
+#endif
+    remove_shadow(worker, &item->tree_item);
+    ring_remove(&item->tree_item.base.siblings_link);
+    ring_remove(&item->list_link);
+    release_drawable(worker, item);
+    worker->current_size--;
+}
+
+static void remove_drawable(RedWorker *worker, Drawable *item)
+{
+    red_pipe_remove_drawable(worker, item);
+    current_remove_drawable(worker, item);
+}
+
+static inline void current_remove(RedWorker *worker, TreeItem *item)
+{
+    TreeItem *now = item;
+
+    for (;;) {
+        Container *container = now->container;
+        RingItem *ring_item;
+
+        if (now->type == TREE_ITEM_TYPE_DRAWABLE) {
+            ring_item = now->siblings_link.prev;
+            remove_drawable(worker, CONTAINEROF(now, Drawable, tree_item));
+        } else {
+            Container *container = (Container *)now;
+
+            ASSERT(now->type == TREE_ITEM_TYPE_CONTAINER);
+
+            if ((ring_item = ring_get_head(&container->items))) {
+                now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+                continue;
+            }
+            ring_item = now->siblings_link.prev;
+            current_remove_container(worker, container);
+        }
+        if (now == item) {
+            return;
+        }
+
+        if ((ring_item = ring_next(&container->items, ring_item))) {
+            now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+        } else {
+            now = (TreeItem *)container;
+        }
+    }
+}
+
+static void current_tree_for_each(RedWorker *worker, void (*f)(TreeItem *, void *), void * data)
+{
+    Ring *ring = &worker->current;
+    RingItem *ring_item;
+    Ring *top_ring;
+
+    if (!(ring_item = ring_get_head(ring))) {
+        return;
+    }
+    top_ring = ring;
+
+    for (;;) {
+        TreeItem *now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+
+        f(now, data);
+
+        if (now->type == TREE_ITEM_TYPE_CONTAINER) {
+            Container *container = (Container *)now;
+
+            if ((ring_item = ring_get_head(&container->items))) {
+                ring = &container->items;
+                continue;
+            }
+        }
+        for (;;) {
+            ring_item = ring_next(ring, &now->siblings_link);
+            if (ring_item) {
+                break;
+            }
+            if (ring == top_ring) {
+                return;
+            }
+            now = (TreeItem *)now->container;
+            ring = (now->container) ? &now->container->items : top_ring;
+        }
+    }
+}
+
+static void red_current_clear(RedWorker *worker)
+{
+    RingItem *ring_item;
+
+    while ((ring_item = ring_get_head(&worker->current))) {
+        TreeItem *now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+        current_remove(worker, now);
+    }
+}
+
+#ifdef PIPE_DEBUG
+
+static void print_rgn(const char* prefix, const QRegion* rgn)
+{
+    int i;
+    printf("TEST: %s: RGN: bbox %u %u %u %u\n",
+           prefix,
+           rgn->bbox.top,
+           rgn->bbox.left,
+           rgn->bbox.bottom,
+           rgn->bbox.right);
+
+    for (i = 0; i < rgn->num_rects; i++) {
+        printf("TEST: %s: RECT %u %u %u %u\n",
+               prefix,
+               rgn->rects[i].top,
+               rgn->rects[i].left,
+               rgn->rects[i].bottom,
+               rgn->rects[i].right);
+    }
+}
+
+static void print_draw_item(const char* prefix, const DrawItem *draw_item)
+{
+    const TreeItem *base = &draw_item->base;
+    const Drawable *drawable = CONTAINEROF(draw_item, Drawable, tree_item);
+    printf("TEST: %s: draw id %u container %u effect %u",
+           prefix,
+           base->id, base->container ? base->container->base.id : 0,
+           draw_item->effect);
+    if (draw_item->shadow) {
+        printf(" shadow %u\n", draw_item->shadow->base.id);
+    } else {
+        printf("\n");
+    }
+    print_rgn(prefix, &base->rgn);
+}
+
+static void print_shadow_item(const char* prefix, const Shadow *item)
+{
+    printf("TEST: %s: shadow %p id %d\n", prefix, item, item->base.id);
+    print_rgn(prefix, &item->base.rgn);
+}
+
+static void print_container_item(const char* prefix, const Container *item)
+{
+    printf("TEST: %s: container %p id %d\n", prefix, item, item->base.id);
+    print_rgn(prefix, &item->base.rgn);
+}
+
+static void print_base_item(const char* prefix, const TreeItem *base)
+{
+    switch (base->type) {
+    case TREE_ITEM_TYPE_DRAWABLE:
+        print_draw_item(prefix, (const DrawItem *)base);
+        break;
+    case TREE_ITEM_TYPE_SHADOW:
+        print_shadow_item(prefix, (const Shadow *)base);
+        break;
+    case TREE_ITEM_TYPE_CONTAINER:
+        print_container_item(prefix, (const Container *)base);
+        break;
+    default:
+        red_error("invalid type %u", base->type);
+    }
+}
+
+void __show_current(TreeItem *item, void *data)
+{
+    print_base_item("TREE", item);
+}
+
+static void show_current(RedWorker *worker)
+{
+    if (ring_is_empty(&worker->current)) {
+        red_printf("TEST: TREE: EMPTY");
+        return;
+    }
+    current_tree_for_each(worker, __show_current, NULL);
+}
+
+#else
+#define print_rgn(a, b)
+#define print_draw_private(a, b)
+#define show_current(a)
+#define print_shadow_item(a, b)
+#define print_base_item(a, b)
+#endif
+
+static inline Shadow *__find_shadow(TreeItem *item)
+{
+    while (item->type == TREE_ITEM_TYPE_CONTAINER) {
+        if (!(item = (TreeItem *)ring_get_tail(&((Container *)item)->items))) {
+            return NULL;
+        }
+    }
+
+    if (item->type != TREE_ITEM_TYPE_DRAWABLE) {
+        return NULL;
+    }
+
+    return ((DrawItem *)item)->shadow;
+}
+
+static inline Ring *ring_of(RedWorker *worker, TreeItem *item)
+{
+    return (item->container) ? &item->container->items : &worker->current;
+}
+
+static inline int __contained_by(RedWorker *worker, TreeItem *item, Ring *ring)
+{
+    ASSERT(item && ring);
+    do {
+        Ring *now = ring_of(worker, item);
+        if (now == ring) {
+            return TRUE;
+        }
+    } while ((item = (TreeItem *)item->container));
+
+    return FALSE;
+}
+
+static inline void __exclude_region(RedWorker *worker, TreeItem *item, QRegion *rgn,
+                                    Ring **top_ring, Drawable *frame_candidate)
+{
+    QRegion and_rgn;
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+
+    region_clone(&and_rgn, rgn);
+    region_and(&and_rgn, &item->rgn);
+    if (!region_is_empty(&and_rgn)) {
+        if (IS_DRAW_ITEM(item)) {
+            DrawItem *draw = (DrawItem *)item;
+
+            if (draw->effect == QXL_EFFECT_OPAQUE) {
+                region_exclude(rgn, &and_rgn);
+            }
+
+            if (draw->shadow) {
+                Shadow *shadow;
+                int32_t x = item->rgn.bbox.left;
+                int32_t y = item->rgn.bbox.top;
+
+                region_exclude(&draw->base.rgn, &and_rgn);
+                shadow = draw->shadow;
+                region_offset(&and_rgn, shadow->base.rgn.bbox.left - x,
+                              shadow->base.rgn.bbox.top - y);
+                region_exclude(&shadow->base.rgn, &and_rgn);
+                region_and(&and_rgn, &shadow->on_hold);
+                if (!region_is_empty(&and_rgn)) {
+                    region_exclude(&shadow->on_hold, &and_rgn);
+                    region_or(rgn, &and_rgn);
+                    // in flat representation of current, shadow is always his owner next
+                    if (!__contained_by(worker, (TreeItem*)shadow, *top_ring)) {
+                        *top_ring = ring_of(worker, (TreeItem*)shadow);
+                    }
+                }
+            } else {
+                if (frame_candidate) {
+                    Drawable *drawable = CONTAINEROF(draw, Drawable, tree_item);
+                    red_stream_maintenance(worker, frame_candidate, drawable);
+                }
+                region_exclude(&draw->base.rgn, &and_rgn);
+            }
+        } else if (item->type == TREE_ITEM_TYPE_CONTAINER) {
+            region_exclude(&item->rgn, &and_rgn);
+
+            if (region_is_empty(&item->rgn)) {  //assume container removal will follow
+                Shadow *shadow;
+
+                region_exclude(rgn, &and_rgn);
+                if ((shadow = __find_shadow(item))) {
+                    region_or(rgn, &shadow->on_hold);
+                    if (!__contained_by(worker, (TreeItem*)shadow, *top_ring)) {
+                        *top_ring = ring_of(worker, (TreeItem*)shadow);
+                    }
+                }
+            }
+        } else {
+            Shadow *shadow;
+
+            ASSERT(item->type == TREE_ITEM_TYPE_SHADOW);
+            shadow = (Shadow *)item;
+            region_exclude(rgn, &and_rgn);
+            region_or(&shadow->on_hold, &and_rgn);
+        }
+    }
+    region_destroy(&and_rgn);
+    stat_add(&worker->__exclude_stat, start_time);
+}
+
+#ifdef USE_EXCLUDE_RGN
+
+static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, QRegion *rgn,
+                           TreeItem **last, Drawable *frame_candidate)
+{
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    Ring *top_ring;
+
+    if (!ring_item) {
+        return;
+    }
+
+    top_ring = ring;
+
+    for (;;) {
+        TreeItem *now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+        Container *container = now->container;
+
+        ASSERT(!region_is_empty(&now->rgn));
+
+        if (region_intersects(rgn, &now->rgn)) {
+            print_base_item("EXCLUDE2", now);
+            __exclude_region(worker, now, rgn, &top_ring, frame_candidate);
+            print_base_item("EXCLUDE3", now);
+
+            if (region_is_empty(&now->rgn)) {
+                ASSERT(now->type != TREE_ITEM_TYPE_SHADOW);
+                ring_item = now->siblings_link.prev;
+                print_base_item("EXCLUDE_REMOVE", now);
+                current_remove(worker, now);
+                if (last && *last == now) {
+                    *last = (TreeItem *)ring_next(ring, ring_item);
+                }
+            } else if (now->type == TREE_ITEM_TYPE_CONTAINER) {
+                Container *container = (Container *)now;
+                if ((ring_item = ring_get_head(&container->items))) {
+                    ring = &container->items;
+                    ASSERT(((TreeItem *)ring_item)->container);
+                    continue;
+                }
+                ring_item = &now->siblings_link;
+            }
+
+            if (region_is_empty(rgn)) {
+                stat_add(&worker->exclude_stat, start_time);
+                return;
+            }
+        }
+
+        while ((last && *last == (TreeItem *)ring_item) ||
+               !(ring_item = ring_next(ring, ring_item))) {
+            if (ring == top_ring) {
+                stat_add(&worker->exclude_stat, start_time);
+                return;
+            }
+            ring_item = &container->base.siblings_link;
+            container = container->base.container;
+            ring = (container) ? &container->items : top_ring;
+        }
+    }
+}
+
+#else
+
+static void exclude_region(RedWorker *worker, Ring *ring, RingItem *ring_item, QRegion *rgn)
+{
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    Ring *top_ring;
+
+    if (!ring_item) {
+        return;
+    }
+
+    top_ring = ring;
+
+    for (;;) {
+        TreeItem *now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+        Container *container = now->container;
+
+        ASSERT(!region_is_empty(&now->rgn));
+
+        if (region_test(rgn, &now->rgn, REGION_TEST_SHARED)) {
+            print_base_item("EXCLUDE2", now);
+            __exclude_region(worker, now, rgn, &top_ring);
+            print_base_item("EXCLUDE3", now);
+
+            if (region_is_empty(&now->rgn)) {
+                ASSERT(now->type != TREE_ITEM_TYPE_SHADOW);
+                ring_item = now->siblings_link.prev;
+                print_base_item("EXCLUDE_REMOVE", now);
+                current_remove(worker, now);
+            } else if (now->type == TREE_ITEM_TYPE_CONTAINER) {
+                Container *container = (Container *)now;
+                if ((ring_item = ring_get_head(&container->items))) {
+                    ring = &container->items;
+                    ASSERT(((TreeItem *)ring_item)->container);
+                    continue;
+                }
+                ring_item = &now->siblings_link;
+            }
+
+            if (region_is_empty(rgn)) {
+                stat_add(&worker->exclude_stat, start_time);
+                return;
+            }
+        }
+
+        while (!(ring_item = ring_next(ring, ring_item))) {
+            if (ring == top_ring) {
+                stat_add(&worker->exclude_stat, start_time);
+                return;
+            }
+            ring_item = &container->base.siblings_link;
+            container = container->base.container;
+            ring = (container) ? &container->items : top_ring;
+        }
+    }
+}
+
+#endif
+
+static inline Container *__new_container(RedWorker *worker, DrawItem *item)
+{
+    Container *container = malloc(sizeof(Container));
+    if (!container) {
+        return NULL;
+    }
+    worker->containers_count++;
+#ifdef PIPE_DEBUG
+    container->base.id = ++worker->last_id;
+#endif
+    container->base.type = TREE_ITEM_TYPE_CONTAINER;
+    container->base.container = item->base.container;
+    item->base.container = container;
+    item->container_root = TRUE;
+    region_clone(&container->base.rgn, &item->base.rgn);
+    ring_item_init(&container->base.siblings_link);
+    ring_add_after(&container->base.siblings_link, &item->base.siblings_link);
+    ring_remove(&item->base.siblings_link);
+    ring_init(&container->items);
+    ring_add(&container->items, &item->base.siblings_link);
+
+    return container;
+}
+
+static inline int is_opaque_item(TreeItem *item)
+{
+    return item->type == TREE_ITEM_TYPE_CONTAINER ||
+           (IS_DRAW_ITEM(item) && ((DrawItem *)item)->effect == QXL_EFFECT_OPAQUE);
+}
+
+static inline void __current_add_drawable(RedWorker *worker, Drawable *drawable, RingItem *pos)
+{
+    ring_add_after(&drawable->tree_item.base.siblings_link, pos);
+    ring_add(&worker->current_list, &drawable->list_link);
+    drawable->refs++;
+}
+
+#ifdef USE_EXCLUDE_RGN
+
+static int is_equal_path(ADDRESS p1, ADDRESS p2, long phys_delta)
+{
+    QXLPath *path1;
+    QXLPath *path2;
+    QXLDataChunk *chunk1;
+    QXLDataChunk *chunk2;
+    uint8_t *data1;
+    uint8_t *data2;
+    int size;
+    int size1;
+    int size2;
+
+    ASSERT(p1 && p2);
+
+    path1 = (QXLPath *)(p1 + phys_delta);
+    path2 = (QXLPath *)(p2 + phys_delta);
+
+    if ((size = path1->data_size) != path2->data_size) {
+        return FALSE;
+    }
+    ASSERT(size);
+
+    chunk1 = &path1->chunk;
+    size1 = chunk1->data_size;
+    data1 = chunk1->data;
+
+    chunk2 = &path2->chunk;
+    size2 = chunk2->data_size;
+    data2 = chunk2->data;
+
+    for (;;) {
+        int now = MIN(size1, size2);
+        ASSERT(now);
+        if (memcmp(data1, data2, now)) {
+            return FALSE;
+        }
+        if (!(size -= now)) {
+            return TRUE;
+        }
+        if ((size1 -= now) == 0) {
+            ASSERT(chunk1->next_chunk)
+            chunk1 = (QXLDataChunk *)(chunk1->next_chunk + phys_delta);
+            size1 = chunk1->data_size;
+            data1 = chunk1->data;
+        } else {
+            data1 += now;
+        }
+
+        if ((size2 -= now) == 0) {
+            ASSERT(chunk2->next_chunk)
+            chunk2 = (QXLDataChunk *)(chunk2->next_chunk + phys_delta);
+            size2 = chunk2->data_size;
+            data2 = chunk2->data;
+        } else {
+            data2 += now;
+        }
+    }
+}
+
+// partial imp
+static int is_equal_brush(Brush *b1, Brush *b2)
+{
+    return b1->type == b2->type && b1->type == BRUSH_TYPE_SOLID && b1->u.color == b1->u.color;
+}
+
+// partial imp
+static int is_equal_line_attr(LineAttr *a1, LineAttr *a2)
+{
+    return a1->flags == a2->flags && a1->join_style == a2->join_style &&
+           a1->end_style == a2->end_style && a1->style_nseg == a2->style_nseg &&
+           a1->width == a2->width && a1->miter_limit == a2->miter_limit &&
+           a1->style_nseg == 0;
+}
+
+static inline int rect_is_equal(const Rect *r1, const Rect *r2)
+{
+    return r1->top == r2->top && r1->left == r2->left &&
+           r1->bottom == r2->bottom && r1->right == r2->right;
+}
+
+// partial imp
+static int is_same_geometry(QXLDrawable *d1, QXLDrawable *d2, long phys_delta)
+{
+    if (d1->type != d2->type) {
+        return FALSE;
+    }
+
+    switch (d1->type) {
+    case QXL_DRAW_STROKE:
+        return is_equal_line_attr(&d1->u.stroke.attr, &d2->u.stroke.attr) &&
+               is_equal_path(d1->u.stroke.path, d2->u.stroke.path, phys_delta);
+    case QXL_DRAW_FILL:
+        return rect_is_equal(&d1->bbox, &d2->bbox);
+    default:
+        return FALSE;
+    }
+}
+
+static int is_same_drawable(QXLDrawable *d1, QXLDrawable *d2, long phys_delta)
+{
+    if (!is_same_geometry(d1, d2, phys_delta)) {
+        return FALSE;
+    }
+
+    switch (d1->type) {
+    case QXL_DRAW_STROKE:
+        return is_equal_brush(&d1->u.stroke.brush, &d2->u.stroke.brush);
+    case QXL_DRAW_FILL:
+        return is_equal_brush(&d1->u.fill.brush, &d2->u.fill.brush);
+    default:
+        return FALSE;
+    }
+}
+
+static inline void red_free_stream(RedWorker *worker, Stream *stream)
+{
+    stream->next = worker->free_streams;
+    worker->free_streams = stream;
+}
+
+static void red_release_stream(RedWorker *worker, Stream *stream)
+{
+    if (!--stream->refs) {
+#ifdef STREAM_TRACE
+        ASSERT(!ring_item_is_linked(&stream->link));
+#else
+        ring_remove(&stream->link);
+#endif
+        pthread_mutex_lock(&avcodec_lock);
+        avcodec_close(stream->av_ctx);
+        pthread_mutex_unlock(&avcodec_lock);
+        av_free(stream->av_ctx);
+        av_free(stream->av_frame);
+        free(stream->frame_buf);
+        red_free_stream(worker, stream);
+    }
+}
+
+#ifdef STREAM_TRACE
+static inline void red_detach_stream(RedWorker *worker, Stream *stream)
+{
+    ASSERT(stream->current && stream->current->stream);
+    ASSERT(stream->current->stream == stream);
+    stream->current->stream = NULL;
+    stream->current = NULL;
+}
+
+static StreamClipItem *__new_stream_clip(DisplayChannel* channel, StreamAgent *agent)
+{
+    StreamClipItem *item = (StreamClipItem *)malloc(sizeof(*item));
+    if (!item) {
+        PANIC("alloc failed");
+    }
+    red_pipe_item_init((PipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP);
+
+    item->stream_agent = agent;
+    agent->stream->refs++;
+    item->refs = 1;
+    return item;
+}
+
+static void push_stream_clip_by_drawable(DisplayChannel* channel, StreamAgent *agent,
+                                         Drawable *drawable)
+{
+    StreamClipItem *item = __new_stream_clip(channel, agent);
+    if (!item) {
+        PANIC("alloc failed");
+    }
+
+    if (drawable->qxl_drawable->clip.type == CLIP_TYPE_NONE) {
+        region_init(&item->region);
+        item->clip_type = CLIP_TYPE_NONE;
+    } else {
+        item->clip_type = CLIP_TYPE_RECTS;
+        region_clone(&item->region, &drawable->tree_item.base.rgn);
+    }
+    red_pipe_add((RedChannel*)channel, (PipeItem *)item);
+}
+
+static void push_stream_clip(DisplayChannel* channel, StreamAgent *agent)
+{
+    StreamClipItem *item = __new_stream_clip(channel, agent);
+    if (!item) {
+        PANIC("alloc failed");
+    }
+    item->clip_type = CLIP_TYPE_RECTS;
+    region_clone(&item->region, &agent->vis_region);
+    red_pipe_add((RedChannel*)channel, (PipeItem *)item);
+}
+
+static void red_display_release_stream_clip(DisplayChannel* channel, StreamClipItem *item)
+{
+    if (!--item->refs) {
+        red_display_release_stream(channel, item->stream_agent);
+        region_destroy(&item->region);
+        free(item);
+    }
+}
+
+static void red_attach_stream(RedWorker *worker, Drawable *drawable, Stream *stream)
+{
+    DisplayChannel *channel;
+    ASSERT(!drawable->stream && !stream->current);
+    ASSERT(drawable && stream);
+    stream->current = drawable;
+    drawable->stream = stream;
+    stream->last_time = drawable->creation_time;
+
+    if ((channel = worker->display_channel)) {
+        StreamAgent *agent = &channel->stream_agents[stream - worker->streams_buf];
+        if (!region_is_equal(&agent->vis_region, &drawable->tree_item.base.rgn)) {
+            region_destroy(&agent->vis_region);
+            region_clone(&agent->vis_region, &drawable->tree_item.base.rgn);
+            push_stream_clip_by_drawable(channel, agent, drawable);
+        }
+    }
+}
+
+#endif
+
+static void red_stop_stream(RedWorker *worker, Stream *stream)
+{
+    DisplayChannel *channel;
+#ifdef STREAM_TRACE
+    ASSERT(ring_item_is_linked(&stream->link));
+    ASSERT(!stream->current);
+#else
+    ASSERT(stream->current && stream->current->stream);
+    stream->current->stream = NULL;
+    stream->current = NULL;
+#endif
+
+    if ((channel = worker->display_channel)) {
+        StreamAgent *stream_agent;
+        stream_agent = &channel->stream_agents[stream - worker->streams_buf];
+        region_clear(&stream_agent->vis_region);
+        ASSERT(!pipe_item_is_linked(&stream_agent->destroy_item));
+        stream->refs++;
+        red_pipe_add(&channel->base, &stream_agent->destroy_item);
+    }
+#ifdef STREAM_TRACE
+    ring_remove(&stream->link);
+#endif
+    red_release_stream(worker, stream);
+}
+
+#ifdef STREAM_TRACE
+static inline void red_detach_stream_gracefully(RedWorker *worker, Stream *stream)
+{
+    DisplayChannel *channel;
+    ASSERT(stream->current);
+
+    if ((channel = worker->display_channel) && !pipe_item_is_linked(&stream->current->pipe_item)) {
+        UpgradeItem *upgrade_item;
+
+        if (!(upgrade_item = (UpgradeItem *)malloc(sizeof(*upgrade_item)))) {
+            PANIC("malloc failed");
+        }
+        upgrade_item->refs = 1;
+        red_pipe_item_init(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE);
+        upgrade_item->drawable = stream->current;
+        upgrade_item->drawable->refs++;
+        region_clone(&upgrade_item->region, &upgrade_item->drawable->tree_item.base.rgn);
+        red_pipe_add((RedChannel *)channel, &upgrade_item->base);
+    }
+    red_detach_stream(worker, stream);
+}
+
+#else
+static inline void red_stop_stream_gracefully(RedWorker *worker, Stream *stream)
+{
+    ASSERT(stream->current);
+    if (worker->display_channel && !pipe_item_is_linked(&stream->current->pipe_item)) {
+        UpgradeItem *item;
+        if ((item = (UpgradeItem *)malloc(sizeof(*item)))) {
+            item->refs = 1;
+            red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_UPGRADE);
+            item->drawable = stream->current;
+            item->drawable->refs++;
+            region_clone(&item->region, &item->drawable->tree_item.base.rgn);
+            red_pipe_add((RedChannel *)worker->display_channel, &item->base);
+        }
+    }
+    red_stop_stream(worker, stream);
+}
+
+#endif
+
+#ifdef STREAM_TRACE
+static void red_detach_streams_behind(RedWorker *worker, QRegion *region)
+{
+    Ring *ring = &worker->streams;
+    RingItem *item = ring_get_head(ring);
+    DisplayChannel *channel = worker->display_channel;
+
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        item = ring_next(ring, item);
+
+        if (channel) {
+            StreamAgent *agent = &channel->stream_agents[stream - worker->streams_buf];
+            if (region_intersects(&agent->vis_region, region)) {
+                region_clear(&agent->vis_region);
+                push_stream_clip(channel, agent);
+                if (stream->current) {
+                    red_detach_stream_gracefully(worker, stream);
+                }
+            }
+        } else if (stream->current && region_intersects(&stream->current->tree_item.base.rgn,
+                                                        region)) {
+            red_detach_stream(worker, stream);
+        }
+    }
+}
+
+#else
+static void red_stop_streams_behind(RedWorker *worker, QRegion *region)
+{
+    Ring *ring = &worker->streams;
+    RingItem *item = ring_get_head(ring);
+
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        stream->refs++;
+        if (stream->current && region_intersects(region, &stream->current->tree_item.base.rgn)) {
+            red_stop_stream_gracefully(worker, stream);
+        }
+        item = ring_next(ring, item);
+        red_release_stream(worker, stream);
+    }
+}
+
+#endif
+
+static void red_streams_update_clip(RedWorker *worker, Drawable *drawable)
+{
+    DisplayChannel *channel;
+    Ring *ring;
+    RingItem *item;
+
+    if (!(channel = worker->display_channel)) {
+        return;
+    }
+
+    ring = &worker->streams;
+    item = ring_get_head(ring);
+
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        StreamAgent *agent;
+
+        item = ring_next(ring, item);
+
+        agent = &channel->stream_agents[stream - worker->streams_buf];
+
+        if (stream->current == drawable) {
+            continue;
+        }
+
+        if (region_intersects(&agent->vis_region, &drawable->tree_item.base.rgn)) {
+            region_exclude(&agent->vis_region, &drawable->tree_item.base.rgn);
+            push_stream_clip(channel, agent);
+        }
+    }
+}
+
+static inline unsigned int red_get_streams_timout(RedWorker *worker)
+{
+    unsigned int timout = -1;
+    Ring *ring = &worker->streams;
+    RingItem *item = ring;
+    struct timespec time;
+
+    clock_gettime(CLOCK_MONOTONIC, &time);
+    red_time_t now = timespec_to_red_time(&time);
+    while ((item = ring_next(ring, item))) {
+        Stream *stream;
+
+        stream = CONTAINEROF(item, Stream, link);
+#ifdef STREAM_TRACE
+        red_time_t delta = (stream->last_time + RED_STREAM_TIMOUT) - now;
+
+        if (delta < 1000 * 1000) {
+            return 0;
+        }
+        timout = MIN(timout, (unsigned int)(delta / (1000 * 1000)));
+#else
+        if (stream->current) {
+            red_time_t delta = (stream->current->creation_time + RED_STREAM_TIMOUT) - now;
+            if (delta < 1000 * 1000) {
+                return 0;
+            }
+            timout = MIN(timout, (unsigned int)(delta / (1000 * 1000)));
+        }
+#endif
+    }
+    return timout;
+}
+
+static inline void red_handle_streams_timout(RedWorker *worker)
+{
+    Ring *ring = &worker->streams;
+    struct timespec time;
+    RingItem *item;
+
+    clock_gettime(CLOCK_MONOTONIC, &time);
+    red_time_t now = timespec_to_red_time(&time);
+    item = ring_get_head(ring);
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+#ifdef STREAM_TRACE
+        item = ring_next(ring, item);
+        if (now >= (stream->last_time + RED_STREAM_TIMOUT)) {
+            if (stream->current) {
+                red_detach_stream_gracefully(worker, stream);
+            }
+            red_stop_stream(worker, stream);
+        }
+#else
+        stream->refs++;
+        if (stream->current && now >= (stream->current->creation_time + RED_STREAM_TIMOUT)) {
+            red_stop_stream_gracefully(worker, stream);
+        }
+        item = ring_next(ring, item);
+        red_release_stream(worker, stream);
+#endif
+    }
+}
+
+static void red_display_release_stream(DisplayChannel *display, StreamAgent *agent)
+{
+    ASSERT(agent->stream);
+    red_release_stream(display->base.worker, agent->stream);
+}
+
+static inline Stream *red_alloc_stream(RedWorker *worker)
+{
+    Stream *stream;
+    if (!worker->free_streams) {
+        return NULL;
+    }
+    stream = worker->free_streams;
+    worker->free_streams = worker->free_streams->next;
+    return stream;
+}
+
+static int get_bit_rate(int width, int height)
+{
+    uint64_t bit_rate = width * height * BEST_BIT_RATE_PER_PIXEL;
+    if (IS_LOW_BANDWIDTH()) {
+        bit_rate = MIN(bitrate_per_sec * 70 / 100, bit_rate);
+        bit_rate = MAX(bit_rate, width * height * WARST_BIT_RATE_PER_PIXEL);
+    }
+    return bit_rate;
+}
+
+static void red_dispaly_create_stream(DisplayChannel *display, Stream *stream)
+{
+    StreamAgent *agent = &display->stream_agents[stream - display->base.worker->streams_buf];
+    stream->refs++;
+    ASSERT(region_is_empty(&agent->vis_region));
+    if (stream->current) {
+        agent->frames = 1;
+        region_clone(&agent->vis_region, &stream->current->tree_item.base.rgn);
+    } else {
+        agent->frames = 0;
+    }
+    agent->drops = 0;
+    agent->fps = MAX_FPS;
+    reset_rate(agent);
+    red_pipe_add(&display->base, &agent->create_item);
+}
+
+static AVCodecContext *red_init_video_encoder(int width, int height)
+{
+    AVCodec *codec;
+    AVCodecContext *ctx;
+    int r;
+
+    codec = avcodec_find_encoder(CODEC_ID_MJPEG);
+
+    if (!codec) {
+        red_printf("codec not found");
+        return NULL;
+    }
+
+    if (!(ctx = avcodec_alloc_context())) {
+        red_printf("alloc ctx failed");
+        return NULL;
+    }
+    ctx->bit_rate = get_bit_rate(width, height);
+    ASSERT(width % 2 == 0);
+    ASSERT(height % 2 == 0);
+    ctx->width = width;
+    ctx->height = height;
+    ctx->time_base = (AVRational){1, MAX_FPS};
+    ctx->gop_size = 10;
+    ctx->max_b_frames = 0;
+    ctx->pix_fmt = PIX_FMT_YUVJ420P;
+
+    pthread_mutex_lock(&avcodec_lock);
+    r = avcodec_open(ctx, codec);
+    pthread_mutex_unlock(&avcodec_lock);
+    if (r < 0) {
+        red_printf("avcodec open failed");
+        av_free(ctx);
+        return NULL;
+    }
+    return ctx;
+}
+
+static void red_create_stream(RedWorker *worker, Drawable *drawable)
+{
+    AVCodecContext *av_ctx;
+    Stream *stream;
+    AVFrame *frame;
+    uint8_t* frame_buf;
+    Rect* src_rect;
+    int stream_width;
+    int stream_height;
+    int pict_size;
+
+    ASSERT(!drawable->stream);
+
+    if (!(stream = red_alloc_stream(worker))) {
+        return;
+    }
+
+    ASSERT(drawable->qxl_drawable->type == QXL_DRAW_COPY);
+    src_rect = &drawable->qxl_drawable->u.copy.src_area;
+    stream_width = ALIGN(src_rect->right - src_rect->left, 2);
+    stream_height = ALIGN(src_rect->bottom - src_rect->top, 2);
+
+    if (!(av_ctx = red_init_video_encoder(stream_width, stream_height))) {
+        goto error_1;
+    }
+
+    if (!(frame = avcodec_alloc_frame())) {
+        goto error_2;
+    }
+
+    if ((pict_size = avpicture_get_size(av_ctx->pix_fmt, stream_width, stream_height)) < 0) {
+        goto error_3;
+    }
+
+    if (!(frame_buf = malloc(pict_size))) {
+        goto error_3;
+    }
+
+    if (avpicture_fill((AVPicture *)frame, frame_buf, av_ctx->pix_fmt, stream_width,
+                       stream_height) < 0) {
+        goto error_4;
+    }
+
+    ring_add(&worker->streams, &stream->link);
+    stream->current = drawable;
+#ifdef STREAM_TRACE
+    stream->last_time = drawable->creation_time;
+    stream->width = src_rect->right - src_rect->left;
+    stream->height = src_rect->bottom - src_rect->top;
+    stream->dest_area = drawable->qxl_drawable->bbox;
+#endif
+    stream->refs = 1;
+    stream->av_ctx = av_ctx;
+    stream->bit_rate = av_ctx->bit_rate;
+    stream->av_frame = frame;
+    stream->frame_buf = frame_buf;
+    stream->frame_buf_end = frame_buf + pict_size;
+    QXLImage *qxl_image = (QXLImage *)(drawable->qxl_drawable->u.copy.src_bitmap +
+                                       worker->dev_info.phys_delta);
+    stream->top_down = !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN);
+    drawable->stream = stream;
+
+    if (worker->display_channel) {
+        red_dispaly_create_stream(worker->display_channel, stream);
+    }
+
+    return;
+
+error_4:
+    free(frame_buf);
+
+error_3:
+    av_free(frame);
+
+error_2:
+    pthread_mutex_lock(&avcodec_lock);
+    avcodec_close(av_ctx);
+    pthread_mutex_unlock(&avcodec_lock);
+    av_free(av_ctx);
+
+error_1:
+    red_free_stream(worker, stream);
+}
+
+static void red_disply_start_streams(DisplayChannel *display_channel)
+{
+    Ring *ring = &display_channel->base.worker->streams;
+    RingItem *item = ring;
+
+    while ((item = ring_next(ring, item))) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        red_dispaly_create_stream(display_channel, stream);
+    }
+}
+
+static void red_display_init_streams(DisplayChannel *display)
+{
+    int i;
+    for (i = 0; i < NUM_STREAMS; i++) {
+        StreamAgent *agent = &display->stream_agents[i];
+        agent->stream = &display->base.worker->streams_buf[i];
+        region_init(&agent->vis_region);
+        red_pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
+        red_pipe_item_init(&agent->destroy_item, PIPE_ITEM_TYPE_STREAM_DESTROY);
+    }
+}
+
+static void red_display_destroy_streams(DisplayChannel *display)
+{
+    int i;
+    for (i = 0; i < NUM_STREAMS; i++) {
+        StreamAgent *agent = &display->stream_agents[i];
+        region_destroy(&agent->vis_region);
+    }
+}
+
+static void red_init_streams(RedWorker *worker)
+{
+    int i;
+
+    ring_init(&worker->streams);
+    worker->free_streams = NULL;
+    for (i = 0; i < NUM_STREAMS; i++) {
+        Stream *stream = &worker->streams_buf[i];
+        ring_item_init(&stream->link);
+        red_free_stream(worker, stream);
+    }
+}
+
+#ifdef STREAM_TRACE
+
+static inline int __red_is_next_stream_frame(const Drawable *candidate,
+                                             const int other_src_width,
+                                             const int other_src_height,
+                                             const Rect *other_dest,
+                                             const red_time_t other_time,
+                                             const Stream *stream,
+                                             unsigned long phys_delta)
+{
+    QXLDrawable *qxl_drawable;
+
+    if (candidate->creation_time - other_time >
+            (stream ? RED_STREAM_CONTINUS_MAX_DELTA : RED_STREAM_DETACTION_MAX_DELTA)) {
+        return FALSE;
+    }
+
+    qxl_drawable = candidate->qxl_drawable;
+
+    if (!rect_is_equal(&qxl_drawable->bbox, other_dest)) {
+        return FALSE;
+    }
+
+    Rect* candidate_src = &qxl_drawable->u.copy.src_area;
+    if (candidate_src->right - candidate_src->left != other_src_width ||
+        candidate_src->bottom - candidate_src->top != other_src_height) {
+        return FALSE;
+    }
+
+    if (stream) {
+        QXLImage *qxl_image = (QXLImage *)(qxl_drawable->u.copy.src_bitmap + phys_delta);
+
+        if (stream->top_down != !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN)) {
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+static inline int red_is_next_stream_frame(const Drawable *candidate, const Drawable *prev,
+                                           const unsigned long phys_delta)
+{
+    if (!candidate->streamable) {
+        return FALSE;
+    }
+
+    Rect* prev_src = &prev->qxl_drawable->u.copy.src_area;
+    return __red_is_next_stream_frame(candidate, prev_src->right - prev_src->left,
+                                      prev_src->bottom - prev_src->top,
+                                      &prev->qxl_drawable->bbox, prev->creation_time,
+                                      prev->stream, phys_delta);
+}
+
+#else
+
+static inline int red_is_next_stream_frame(Drawable *candidate, Drawable *prev,
+                                           unsigned long phys_delta)
+{
+    QXLImage *qxl_image;
+    QXLDrawable *qxl_drawable;
+    QXLDrawable *prev_qxl_drawable;
+
+    if (candidate->creation_time - prev->creation_time >
+            ((prev->stream) ? RED_STREAM_CONTINUS_MAX_DELTA : RED_STREAM_DETACTION_MAX_DELTA)) {
+        return FALSE;
+    }
+
+    qxl_drawable = candidate->qxl_drawable;
+    prev_qxl_drawable = prev->qxl_drawable;
+    if (qxl_drawable->type != QXL_DRAW_COPY || prev_qxl_drawable->type != QXL_DRAW_COPY) {
+        return FALSE;
+    }
+
+    if (!rect_is_equal(&qxl_drawable->bbox, &prev_qxl_drawable->bbox)) {
+        return FALSE;
+    }
+
+    if (!rect_is_same_size(&qxl_drawable->u.copy.src_area, &prev_qxl_drawable->u.copy.src_area)) {
+        return FALSE;
+    }
+
+    if (qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT ||
+                                    prev_qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT) {
+        return FALSE;
+    }
+
+    qxl_image = (QXLImage *)(qxl_drawable->u.copy.src_bitmap + phys_delta);
+
+    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP) {
+        return FALSE;
+    }
+
+    if (prev->stream && prev->stream->top_down != !!(qxl_image->bitmap.flags & BITMAP_TOP_DOWN)) {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+#endif
+
+static void reset_rate(StreamAgent *stream_agent)
+{
+    Stream *stream = stream_agent->stream;
+    AVCodecContext *new_ctx;
+    int rate;
+
+    rate = get_bit_rate(stream->width, stream->height);
+    if (rate == stream->bit_rate) {
+        return;
+    }
+
+    int stream_width = ALIGN(stream->width, 2);
+    int stream_height = ALIGN(stream->height, 2);
+
+    new_ctx = red_init_video_encoder(stream_width, stream_height);
+    if (!new_ctx) {
+        red_printf("craete ctx failed");
+        return;
+    }
+
+    avcodec_close(stream->av_ctx);
+    av_free(stream->av_ctx);
+    stream->av_ctx = new_ctx;
+    stream->bit_rate = rate;
+}
+
+static inline void pre_stream_item_swap(RedWorker *worker, Stream *stream)
+{
+    ASSERT(stream->current);
+
+    if (!worker->display_channel || !IS_LOW_BANDWIDTH()) {
+        return;
+    }
+
+    int index = stream - worker->streams_buf;
+    StreamAgent *agent = &worker->display_channel->stream_agents[index];
+
+    if (pipe_item_is_linked(&stream->current->pipe_item)) {
+        ++agent->drops;
+    }
+
+    if (agent->frames / agent->fps < FPS_TEST_INTERVAL) {
+        agent->frames++;
+        return;
+    }
+
+    double drop_factor = ((double)agent->frames - (double)agent->drops) / (double)agent->frames;
+
+    if (drop_factor == 1) {
+        if (agent->fps < MAX_FPS) {
+            agent->fps++;
+        }
+    } else if (drop_factor < 0.9) {
+        if (agent->fps > 1) {
+            agent->fps--;
+        }
+    }
+    agent->frames = 1;
+    agent->drops = 0;
+}
+
+static inline void red_stream_maintenance(RedWorker *worker, Drawable *candidate, Drawable *prev)
+{
+    Stream *stream;
+
+    if (candidate->stream) {
+        return;
+    }
+
+#ifdef STREAM_TRACE
+    if (!red_is_next_stream_frame(candidate, prev, worker->dev_info.phys_delta)) {
+        return;
+    }
+#else
+    if (!worker->streaming_video ||
+                        !red_is_next_stream_frame(candidate, prev, worker->dev_info.phys_delta)) {
+        return;
+    }
+#endif
+
+    if ((stream = prev->stream)) {
+#ifdef STREAM_TRACE
+        pre_stream_item_swap(worker, stream);
+        red_detach_stream(worker, stream);
+        prev->streamable = FALSE; //prevent item trace
+        red_attach_stream(worker, candidate, stream);
+#else
+        prev->stream = NULL;
+        candidate->stream = stream;
+        stream->current = candidate;
+
+        if (!region_is_equal(&stream->region, &candidate->tree_item.base.rgn)) {
+            region_destroy(&stream->region);
+            region_clone(&stream->region, &candidate->tree_item.base.rgn);
+            if (worker->display_channel) {
+                int index = stream - worker->streams_buf;
+                StreamAgent *stream_agent = &worker->display_channel->stream_agents[index];
+                if (!pipe_item_is_linked(&stream_agent->clip_item)) {
+                    stream->refs++;
+                    red_pipe_add((RedChannel*)worker->display_channel, &stream_agent->clip_item);
+                }
+            }
+        }
+#endif
+    } else if ((candidate->frames_count = prev->frames_count + 1) ==
+                                                                RED_STREAM_START_CONDITION) {
+        red_create_stream(worker, candidate);
+    }
+}
+
+static inline int red_current_add_equal(RedWorker *worker, DrawItem *item, TreeItem *other)
+{
+    DrawItem *other_draw_item;
+    Drawable *drawable;
+    Drawable *other_drawable;
+    QXLDrawable *qxl_drawable;
+    QXLDrawable *other_qxl_drawable;
+
+    if (other->type != TREE_ITEM_TYPE_DRAWABLE) {
+        return FALSE;
+    }
+    other_draw_item = (DrawItem *)other;
+
+    if (item->shadow || other_draw_item->shadow || item->effect != other_draw_item->effect) {
+        return FALSE;
+    }
+
+    drawable = CONTAINEROF(item, Drawable, tree_item);
+    other_drawable = CONTAINEROF(other_draw_item, Drawable, tree_item);
+
+    qxl_drawable = drawable->qxl_drawable;
+    other_qxl_drawable = other_drawable->qxl_drawable;
+
+    if (item->effect == QXL_EFFECT_OPAQUE) {
+        int add_after = !!other_drawable->stream;
+        red_stream_maintenance(worker, drawable, other_drawable);
+        __current_add_drawable(worker, drawable, &other->siblings_link);
+        if (add_after) {
+            red_pipe_add_drawable_after(worker, drawable, other_drawable);
+        } else {
+            red_pipe_add_drawable(worker, drawable);
+        }
+        remove_drawable(worker, other_drawable);
+        return TRUE;
+    }
+
+    switch (item->effect) {
+    case QXL_EFFECT_REVERT_ON_DUP:
+        if (is_same_drawable(qxl_drawable, other_qxl_drawable, worker->dev_info.phys_delta)) {
+            if (!ring_item_is_linked(&other_drawable->pipe_item.link)) {
+                red_pipe_add_drawable(worker, drawable);
+            }
+            remove_drawable(worker, other_drawable);
+            return TRUE;
+        }
+        break;
+    case QXL_EFFECT_OPAQUE_BRUSH:
+        if (is_same_geometry(qxl_drawable, other_qxl_drawable, worker->dev_info.phys_delta)) {
+            __current_add_drawable(worker, drawable, &other->siblings_link);
+            remove_drawable(worker, other_drawable);
+            red_pipe_add_drawable(worker, drawable);
+            return TRUE;
+        }
+        break;
+    case QXL_EFFECT_NOP_ON_DUP:
+        if (is_same_drawable(qxl_drawable, other_qxl_drawable, worker->dev_info.phys_delta)) {
+            return TRUE;
+        }
+        break;
+    }
+    return FALSE;
+}
+
+#ifdef STREAM_TRACE
+
+static inline void red_use_stream_trace(RedWorker *worker, Drawable *drawable)
+{
+    ItemTrace *trace;
+    ItemTrace *trace_end;
+    Ring *ring;
+    RingItem *item;
+
+    if (drawable->stream || !drawable->streamable || drawable->frames_count) {
+        return;
+    }
+
+
+    ring = &worker->streams;
+    item = ring_get_head(ring);
+
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        if (!stream->current && __red_is_next_stream_frame(drawable,
+                                                           stream->width,
+                                                           stream->height,
+                                                           &stream->dest_area,
+                                                           stream->last_time,
+                                                           stream,
+                                                           worker->dev_info.phys_delta)) {
+            red_attach_stream(worker, drawable, stream);
+            return;
+        }
+        item = ring_next(ring, item);
+    }
+
+    trace = worker->items_trace;
+    trace_end = trace + NUM_TRACE_ITEMS;
+    for (; trace < trace_end; trace++) {
+        if (__red_is_next_stream_frame(drawable, trace->width, trace->height, &trace->dest_area,
+                                       trace->time, NULL, worker->dev_info.phys_delta)) {
+            if ((drawable->frames_count = trace->frames_count + 1) == RED_STREAM_START_CONDITION) {
+                red_create_stream(worker, drawable);
+            }
+            return;
+        }
+    }
+}
+
+static void red_reset_stream_trace(RedWorker *worker)
+{
+    Ring *ring = &worker->streams;
+    RingItem *item = ring_get_head(ring);
+
+    while (item) {
+        Stream *stream = CONTAINEROF(item, Stream, link);
+        item = ring_next(ring, item);
+        if (!stream->current) {
+            red_stop_stream(worker, stream);
+        } else {
+            red_printf("attached stream");
+        }
+    }
+
+    worker->next_item_trace = 0;
+    memset(worker->items_trace, 0, sizeof(worker->items_trace));
+}
+
+#endif
+
+static inline int red_current_add(RedWorker *worker, Drawable *drawable)
+{
+    DrawItem *item = &drawable->tree_item;
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    RingItem *now;
+    Ring *ring = &worker->current;
+    QRegion exclude_rgn;
+    RingItem *exclude_base = NULL;
+
+    print_base_item("ADD", &item->base);
+    ASSERT(!region_is_empty(&item->base.rgn));
+    worker->current_size++;
+    region_init(&exclude_rgn);
+    now = ring_next(ring, ring);
+
+    while (now) {
+        TreeItem *sibling = CONTAINEROF(now, TreeItem, siblings_link);
+        int test_res;
+
+        if (!region_bounds_intersects(&item->base.rgn, &sibling->rgn)) {
+            print_base_item("EMPTY", sibling);
+            now = ring_next(ring, now);
+            continue;
+        }
+        test_res = region_test(&item->base.rgn, &sibling->rgn, REGION_TEST_ALL);
+        if (!(test_res & REGION_TEST_SHARED)) {
+            print_base_item("EMPTY", sibling);
+            now = ring_next(ring, now);
+            continue;
+        } else if (sibling->type != TREE_ITEM_TYPE_SHADOW) {
+            if (!(test_res & REGION_TEST_RIGHT_EXCLUSIVE) &&
+                                                   !(test_res & REGION_TEST_LEFT_EXCLUSIVE) &&
+                                                   red_current_add_equal(worker, item, sibling)) {
+                stat_add(&worker->add_stat, start_time);
+                return FALSE;
+            }
+
+            if (!(test_res & REGION_TEST_RIGHT_EXCLUSIVE) && item->effect == QXL_EFFECT_OPAQUE) {
+                Shadow *shadow;
+                int skip = now == exclude_base;
+                print_base_item("CONTAIN", sibling);
+
+                if ((shadow = __find_shadow(sibling))) {
+                    if (exclude_base) {
+                        TreeItem *next = sibling;
+                        exclude_region(worker, ring, exclude_base, &exclude_rgn, &next, NULL);
+                        if (next != sibling) {
+                            now = next ? &next->siblings_link : NULL;
+                            exclude_base = NULL;
+                            continue;
+                        }
+                    }
+                    region_or(&exclude_rgn, &shadow->on_hold);
+                }
+                now = now->prev;
+                current_remove(worker, sibling);
+                now = ring_next(ring, now);
+                if (shadow || skip) {
+                    exclude_base = now;
+                }
+                continue;
+            }
+
+            if (!(test_res & REGION_TEST_LEFT_EXCLUSIVE) && is_opaque_item(sibling)) {
+                Container *container;
+
+                if (exclude_base) {
+                    exclude_region(worker, ring, exclude_base, &exclude_rgn, NULL, NULL);
+                    region_clear(&exclude_rgn);
+                    exclude_base = NULL;
+                }
+                print_base_item("IN", sibling);
+                if (sibling->type == TREE_ITEM_TYPE_CONTAINER) {
+                    container = (Container *)sibling;
+                    ring = &container->items;
+                    item->base.container = container;
+                    now = ring_next(ring, ring);
+                    continue;
+                }
+                ASSERT(IS_DRAW_ITEM(sibling));
+                if (!((DrawItem *)sibling)->container_root) {
+                    container = __new_container(worker, (DrawItem *)sibling);
+                    if (!container) {
+                        red_printf("create new container failed");
+                        region_destroy(&exclude_rgn);
+                        return FALSE;
+                    }
+                    item->base.container = container;
+                    ring = &container->items;
+                }
+            }
+        }
+        if (!exclude_base) {
+            exclude_base = now;
+        }
+        break;
+    }
+    if (item->effect == QXL_EFFECT_OPAQUE) {
+        region_or(&exclude_rgn, &item->base.rgn);
+        exclude_region(worker, ring, exclude_base, &exclude_rgn, NULL, drawable);
+#ifdef STREAM_TRACE
+        red_use_stream_trace(worker, drawable);
+#endif
+        red_streams_update_clip(worker, drawable);
+    } else {
+#ifdef STREAM_TRACE
+        red_detach_streams_behind(worker, &drawable->tree_item.base.rgn);
+#else
+        red_stop_streams_behind(worker, &drawable->tree_item.base.rgn);
+#endif
+    }
+    region_destroy(&exclude_rgn);
+    __current_add_drawable(worker, drawable, ring);
+    stat_add(&worker->add_stat, start_time);
+    return TRUE;
+}
+
+#else
+
+static inline void __handle_remove_shadow(RedWorker *worker, TreeItem *item)
+{
+    Shadow *shadow;
+    Ring *ring;
+
+    while (item->type == TREE_ITEM_TYPE_CONTAINER) {
+        if (!(item = (TreeItem *)ring_get_tail(&((Container *)item)->items))) {
+            return;
+        }
+    }
+
+    if (item->type != TREE_ITEM_TYPE_DRAWABLE || !(shadow = ((DrawItem *)item)->shadow)) {
+        return;
+    }
+    print_base_item("SHADW", &shadow->base);
+    ring = (shadow->base.container) ? &shadow->base.container->items : &worker->current;
+    exclude_region(worker, ring, ring_next(ring, &shadow->base.siblings_link), &shadow->on_hold);
+    region_clear(&shadow->on_hold);
+}
+
+static inline int red_current_add(RedWorker *worker, Drawable *drawable)
+{
+    DrawItem *item = &drawable->tree_item;
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    RingItem *now;
+    Ring *ring = &worker->current;
+
+    print_base_item("ADD", &item->base);
+    ASSERT(!region_is_empty(&item->base.rgn));
+    worker->current_size++;
+    now = ring_next(ring, ring);
+
+    while (now) {
+        TreeItem *sibling = CONTAINEROF(now, TreeItem, siblings_link);
+        int test_res;
+
+        if (!region_bounds_intersects(&item->base.rgn, &sibling->rgn)) {
+            print_base_item("EMPTY", sibling);
+            now = ring_next(ring, now);
+            continue;
+        }
+        test_res = region_test(&item->base.rgn, &sibling->rgn, REGION_TEST_ALL);
+        if (!(test_res & REGION_TEST_SHARED)) {
+            print_base_item("EMPTY", sibling);
+            now = ring_next(ring, now);
+            continue;
+        } else if (sibling->type != TREE_ITEM_TYPE_SHADOW) {
+            if (!(test_res & REGION_TEST_RIGHT_EXCLUSIVE) && item->effect == QXL_EFFECT_OPAQUE) {
+                print_base_item("CONTAIN", sibling);
+                __handle_remove_shadow(worker, sibling);
+                now = now->prev;
+                current_remove(worker, sibling);
+                now = ring_next(ring, now);
+                continue;
+            }
+
+            if (!(test_res & REGION_TEST_LEFT_EXCLUSIVE) && is_opaque_item(sibling)) {
+                Container *container;
+
+                print_base_item("IN", sibling);
+                if (sibling->type == TREE_ITEM_TYPE_CONTAINER) {
+                    container = (Container *)sibling;
+                    ring = &container->items;
+                    item->base.container = container;
+                    now = ring_next(ring, ring);
+                    continue;
+                }
+                ASSERT(IS_DRAW_ITEM(sibling));
+                if (!((DrawItem *)sibling)->container_root) {
+                    container = __new_container(worker, (DrawItem *)sibling);
+                    if (!container) {
+                        red_printf("create new container failed");
+                        return FALSE;
+                    }
+                    item->base.container = container;
+                    ring = &container->items;
+                }
+            }
+        }
+        if (item->effect == QXL_EFFECT_OPAQUE) {
+            QRegion exclude_rgn;
+            region_clone(&exclude_rgn, &item->base.rgn);
+            exclude_region(worker, ring, now, &exclude_rgn);
+            region_destroy(&exclude_rgn);
+        }
+        break;
+    }
+    __current_add_drawable(worker, drawable, ring);
+    stat_add(&worker->add_stat, start_time);
+    return TRUE;
+}
+
+#endif
+
+static void add_clip_rects(QRegion *rgn, PHYSICAL data, unsigned long phys_delta)
+{
+    while (data) {
+        QXLDataChunk *chunk;
+        Rect *now;
+        Rect *end;
+        chunk = (QXLDataChunk *)(data + phys_delta);
+        now = (Rect *)chunk->data;
+        end = now + chunk->data_size / sizeof(Rect);
+
+        for (; now < end; now++) {
+            Rect* r = (Rect *)now;
+
+            ASSERT(now->top == r->top && now->left == r->left &&
+                   now->bottom == r->bottom && now->right == r->right);
+#ifdef PIPE_DEBUG
+            printf("TEST: DRAWABLE: RECT: %u %u %u %u\n", r->top, r->left, r->bottom, r->right);
+#endif
+            region_add(rgn, r);
+        }
+        data = chunk->next_chunk;
+    }
+}
+
+static inline Shadow *__new_shadow(RedWorker *worker, Drawable *item, Point *delta)
+{
+    ASSERT(delta->x || delta->y);
+
+    Shadow *shadow = malloc(sizeof(Shadow));
+    if (!shadow) {
+        return NULL;
+    }
+    worker->shadows_count++;
+#ifdef PIPE_DEBUG
+    shadow->base.id = ++worker->last_id;
+#endif
+    shadow->base.type = TREE_ITEM_TYPE_SHADOW;
+    shadow->base.container = NULL;
+    shadow->owner = &item->tree_item;
+    region_clone(&shadow->base.rgn, &item->tree_item.base.rgn);
+    region_offset(&shadow->base.rgn, delta->x, delta->y);
+    ring_item_init(&shadow->base.siblings_link);
+    region_init(&shadow->on_hold);
+    item->tree_item.shadow = shadow;
+    return shadow;
+}
+
+static inline int red_current_add_with_shadow(RedWorker *worker, Drawable *item, Point *delta)
+{
+#ifdef RED_WORKER_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    Ring *ring;
+
+    Shadow *shadow = __new_shadow(worker, item, delta);
+    if (!shadow) {
+        stat_add(&worker->add_stat, start_time);
+        return FALSE;
+    }
+    print_base_item("ADDSHADOW", &item->tree_item.base);
+    worker->current_size++;
+    ring = &worker->current;
+    // item and his shadow must initially be placed in the same container.
+    // for now putting them on root.
+#ifdef STREAM_TRACE
+    red_detach_streams_behind(worker, &shadow->base.rgn);
+#else
+    red_stop_streams_behind(worker, &shadow->base.rgn);
+#endif
+    ring_add(ring, &shadow->base.siblings_link);
+    __current_add_drawable(worker, item, ring);
+    if (item->tree_item.effect == QXL_EFFECT_OPAQUE) {
+        QRegion exclude_rgn;
+        region_clone(&exclude_rgn, &item->tree_item.base.rgn);
+#ifdef USE_EXCLUDE_RGN
+        exclude_region(worker, ring, &shadow->base.siblings_link, &exclude_rgn, NULL, NULL);
+#else
+        exclude_region(worker, ring, &shadow->base.siblings_link, &exclude_rgn);
+#endif
+        region_destroy(&exclude_rgn);
+        red_streams_update_clip(worker, item);
+    } else {
+#ifdef STREAM_TRACE
+        red_detach_streams_behind(worker, &item->tree_item.base.rgn);
+#else
+        red_stop_streams_behind(worker, &item->tree_item.base.rgn);
+#endif
+    }
+    stat_add(&worker->add_stat, start_time);
+    return TRUE;
+}
+
+static inline int has_shadow(QXLDrawable *drawable)
+{
+    return drawable->type == QXL_COPY_BITS;
+}
+
+#ifdef STREAM_TRACE
+static inline void red_update_streamable(RedWorker *worker, Drawable *drawable,
+                                         QXLDrawable *qxl_drawable)
+{
+    QXLImage *qxl_image;
+
+    if (!worker->streaming_video) {
+        return;
+    }
+
+    if (drawable->tree_item.effect != QXL_EFFECT_OPAQUE ||
+                                        qxl_drawable->type != QXL_DRAW_COPY ||
+                                        qxl_drawable->u.copy.rop_decriptor != ROPD_OP_PUT) {
+        return;
+    }
+
+    qxl_image = (QXLImage *)(qxl_drawable->u.copy.src_bitmap + worker->dev_info.phys_delta);
+    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP) {
+        return;
+    }
+
+    drawable->streamable = TRUE;
+}
+
+#endif
+
+static inline int red_current_add_qxl(RedWorker *worker, Drawable *drawable,
+                                      QXLDrawable *qxl_drawable)
+{
+    int ret;
+
+    if (has_shadow(qxl_drawable)) {
+        Point delta;
+
+#ifdef RED_WORKER_STAT
+        ++worker->add_with_shadow_count;
+#endif
+        delta.x = qxl_drawable->u.copy_bits.src_pos.x - qxl_drawable->bbox.left;
+        delta.y = qxl_drawable->u.copy_bits.src_pos.y - qxl_drawable->bbox.top;
+        ret = red_current_add_with_shadow(worker, drawable, &delta);
+    } else {
+#ifdef STREAM_TRACE
+        red_update_streamable(worker, drawable, qxl_drawable);
+#endif
+        ret = red_current_add(worker, drawable);
+    }
+#ifdef RED_WORKER_STAT
+    if ((++worker->add_count % 100) == 0) {
+        stat_time_t total = worker->add_stat.total;
+        red_printf("add with shadow count %u",
+                   worker->add_with_shadow_count);
+        worker->add_with_shadow_count = 0;
+        red_printf("add[%u] %f exclude[%u] %f __exclude[%u] %f",
+                   worker->add_stat.count,
+                   stat_cpu_time_to_sec(total),
+                   worker->exclude_stat.count,
+                   stat_cpu_time_to_sec(worker->exclude_stat.total),
+                   worker->__exclude_stat.count,
+                   stat_cpu_time_to_sec(worker->__exclude_stat.total));
+        red_printf("add %f%% exclude %f%% exclude2 %f%% __exclude %f%%",
+                   (double)(total - worker->exclude_stat.total) / total * 100,
+                   (double)(worker->exclude_stat.total) / total * 100,
+                   (double)(worker->exclude_stat.total -
+                            worker->__exclude_stat.total) / worker->exclude_stat.total * 100,
+                   (double)(worker->__exclude_stat.total) / worker->exclude_stat.total * 100);
+        stat_reset(&worker->add_stat);
+        stat_reset(&worker->exclude_stat);
+        stat_reset(&worker->__exclude_stat);
+    }
+#endif
+    return ret;
+}
+
+static void red_get_area(RedWorker *worker, const Rect *area, uint8_t *dest, int dest_stride,
+                         int update)
+{
+    if (update) {
+        red_update_area(worker, area);
+    }
+
+    worker->draw_context.read_pixels(worker->draw_context.canvas, dest, dest_stride, area);
+}
+
+static inline int red_handle_self_bitmap(RedWorker *worker, QXLDrawable *drawable)
+{
+    QXLImage *image;
+    int32_t width;
+    int32_t height;
+    uint8_t *dest;
+    int dest_stride;
+    PHYSICAL *addr;
+
+    if (!drawable->bitmap_offset) {
+        return TRUE;
+    }
+
+    width = drawable->bbox.right - drawable->bbox.left;
+    height = drawable->bbox.bottom - drawable->bbox.top;
+    dest_stride = width * sizeof(uint32_t);
+
+    if (!(image = malloc(sizeof(QXLImage) + height * dest_stride))) {
+        red_printf("alloc failed");
+        return FALSE;
+    }
+    dest = (uint8_t *)(image + 1);
+
+    image->descriptor.type = IMAGE_TYPE_BITMAP;
+    image->descriptor.flags = 0;
+
+    QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_RED, ++worker->bits_unique);
+    image->bitmap.flags = QXL_BITMAP_DIRECT | (worker->draw_context.top_down ?
+                                               QXL_BITMAP_TOP_DOWN : 0);
+    image->bitmap.format = BITMAP_FMT_32BIT;
+    image->bitmap.stride = dest_stride;
+    image->descriptor.width = image->bitmap.x = width;
+    image->descriptor.height = image->bitmap.y = height;
+    image->bitmap.data = (PHYSICAL)(dest - worker->dev_info.phys_delta);
+    image->bitmap.palette = 0;
+
+    red_get_area(worker, &drawable->bitmap_area, dest, dest_stride, TRUE);
+
+    addr = (PHYSICAL *)((uint8_t *)drawable + drawable->bitmap_offset);
+    ASSERT(*addr == 0);
+    *addr = (PHYSICAL)((uint8_t *)image - worker->dev_info.phys_delta);
+    return TRUE;
+}
+
+static void free_one_drawable(RedWorker *worker, int force_glz_free)
+{
+    RingItem *ring_item = ring_get_tail(&worker->current_list);
+    Drawable *drawable;
+    Container *container;
+
+    ASSERT(ring_item);
+    drawable = CONTAINEROF(ring_item, Drawable, list_link);
+    if (drawable->red_glz_drawable && force_glz_free) {
+        ASSERT(worker->display_channel);
+        red_display_free_glz_drawable(worker->display_channel, drawable->red_glz_drawable);
+    }
+    red_draw_drawable(worker, drawable);
+    container = drawable->tree_item.base.container;
+    current_remove_drawable(worker, drawable);
+    container_cleanup(worker, container);
+}
+
+static Drawable *get_drawable(RedWorker *worker, uint8_t effect, QXLDrawable *qxl_drawable)
+{
+    Drawable *drawable;
+    struct timespec time;
+
+    while (!(drawable = alloc_drawable(worker))) {
+        free_one_drawable(worker, FALSE);
+    }
+    memset(drawable, 0, sizeof(Drawable));
+    drawable->refs = 1;
+    clock_gettime(CLOCK_MONOTONIC, &time);
+    drawable->creation_time = timespec_to_red_time(&time);
+#ifdef PIPE_DEBUG
+    drawable->tree_item.base.id = ++worker->last_id;
+#endif
+    ring_item_init(&drawable->list_link);
+#ifdef UPDATE_AREA_BY_TREE
+    ring_item_init(&drawable->collect_link);
+#endif
+    ring_item_init(&drawable->tree_item.base.siblings_link);
+    drawable->tree_item.base.type = TREE_ITEM_TYPE_DRAWABLE;
+    region_init(&drawable->tree_item.base.rgn);
+    drawable->tree_item.effect = effect;
+    red_pipe_item_init(&drawable->pipe_item, PIPE_ITEM_TYPE_DRAW);
+    drawable->qxl_drawable = qxl_drawable;
+
+    return drawable;
+}
+
+static inline void red_process_drawable(RedWorker *worker, QXLDrawable *drawable)
+{
+    Drawable *item = get_drawable(worker, drawable->effect, drawable);
+
+    ASSERT(item);
+    region_add(&item->tree_item.base.rgn, &drawable->bbox);
+#ifdef PIPE_DEBUG
+    printf("TEST: DRAWABLE: id %u type %s effect %u bbox %u %u %u %u\n",
+           item->tree_item.base.id,
+           draw_type_to_str(drawable->type),
+           item->tree_item.effect,
+           drawable->bbox.top, drawable->bbox.left, drawable->bbox.bottom, drawable->bbox.right);
+#endif
+
+    if (drawable->clip.type == CLIP_TYPE_RECTS) {
+        QRegion rgn;
+
+        region_init(&rgn);
+        add_clip_rects(&rgn, drawable->clip.data + OFFSETOF(QXLClipRects, chunk),
+                       worker->dev_info.phys_delta);
+        region_and(&item->tree_item.base.rgn, &rgn);
+        region_destroy(&rgn);
+    } else if (drawable->clip.type == CLIP_TYPE_PATH) {
+        item->tree_item.effect = QXL_EFFECT_BLEND;
+#ifdef PIPE_DEBUG
+        printf("TEST: DRAWABLE: QXL_CLIP_TYPE_PATH\n");
+#endif
+    }
+
+    if (region_is_empty(&item->tree_item.base.rgn)) {
+        release_drawable(worker, item);
+        return;
+    }
+
+    if (!red_handle_self_bitmap(worker, drawable)) {
+        release_drawable(worker, item);
+        return;
+    }
+
+    if (red_current_add_qxl(worker, item, drawable)) {
+        worker->drawable_count++;
+        if (item->tree_item.effect != QXL_EFFECT_OPAQUE) {
+            worker->transparent_count++;
+        }
+        red_pipe_add_drawable(worker, item);
+#ifdef DRAW_ALL
+        red_draw_qxl_drawable(worker, drawable);
+#endif
+    }
+    release_drawable(worker, item);
+}
+
+static void localize_path(PHYSICAL *in_path, long phys_delta)
+{
+    QXLPath *path;
+    uint8_t *data;
+    QXLDataChunk *chunk;
+
+    ASSERT(in_path && *in_path);
+    path = (QXLPath *)(*in_path + phys_delta);
+    data = malloc(sizeof(UINT32) + path->data_size);
+    ASSERT(data);
+    *in_path = (PHYSICAL)data;
+    *(UINT32 *)data = path->data_size;
+    data += sizeof(UINT32);
+    chunk = &path->chunk;
+    do {
+        memcpy(data, chunk->data, chunk->data_size);
+        data += chunk->data_size;
+        chunk = chunk->next_chunk ? (QXLDataChunk *)(chunk->next_chunk + phys_delta) : NULL;
+    } while (chunk);
+}
+
+static void unlocalize_path(PHYSICAL *path)
+{
+    ASSERT(path && *path);
+    free((void *)*path);
+    *path = 0;
+}
+
+static void localize_str(PHYSICAL *in_str, long phys_delta)
+{
+    QXLString *qxl_str = (QXLString *)(*in_str + phys_delta);
+    QXLDataChunk *chunk;
+    String *str;
+    uint8_t *dest;
+
+    ASSERT(in_str);
+    str = malloc(sizeof(UINT32) + qxl_str->data_size);
+    ASSERT(str);
+    *in_str = (PHYSICAL)str;
+    str->length = qxl_str->length;
+    str->flags = qxl_str->flags;
+    dest = str->data;
+    chunk = &qxl_str->chunk;
+    for (;;) {
+        memcpy(dest, chunk->data, chunk->data_size);
+        if (!chunk->next_chunk) {
+            return;
+        }
+        dest += chunk->data_size;
+        chunk = (QXLDataChunk *)(chunk->next_chunk + phys_delta);
+    }
+}
+
+static void unlocalize_str(PHYSICAL *str)
+{
+    ASSERT(str && *str);
+    free((void *)*str);
+    *str = 0;
+}
+
+static void localize_clip(Clip *clip, long phys_delta)
+{
+    switch (clip->type) {
+    case CLIP_TYPE_NONE:
+        return;
+    case CLIP_TYPE_RECTS: {
+        QXLClipRects *clip_rects;
+        QXLDataChunk *chunk;
+        uint8_t *data;
+        clip_rects = (QXLClipRects *)(clip->data + phys_delta);
+        chunk = &clip_rects->chunk;
+        ASSERT(clip->data);
+        data = malloc(sizeof(UINT32) + clip_rects->num_rects * sizeof(Rect));
+        ASSERT(data);
+        clip->data = (PHYSICAL)data;
+        *(UINT32 *)(data) = clip_rects->num_rects;
+        data += sizeof(UINT32);
+        do {
+            memcpy(data, chunk->data, chunk->data_size);
+            data += chunk->data_size;
+            chunk = chunk->next_chunk ? (QXLDataChunk *)(chunk->next_chunk + phys_delta) : NULL;
+        } while (chunk);
+        break;
+    }
+    case CLIP_TYPE_PATH:
+        localize_path(&clip->data, phys_delta);
+        break;
+    default:
+        red_printf("invalid clip type");
+    }
+}
+
+static void unlocalize_clip(Clip *clip)
+{
+    switch (clip->type) {
+    case CLIP_TYPE_NONE:
+        return;
+    case CLIP_TYPE_RECTS:
+        free((void *)clip->data);
+        clip->data = 0;
+        break;
+    case CLIP_TYPE_PATH:
+        unlocalize_path(&clip->data);
+        break;
+    default:
+        red_printf("invalid clip type");
+    }
+}
+
+static LocalImage *alloc_local_image(RedWorker *worker)
+{
+    ASSERT(worker->local_images_pos < MAX_BITMAPS);
+    return &worker->local_images[worker->local_images_pos++];
+}
+
+static ImageCacheItem *image_cache_find(ImageCache *cache, UINT64 id)
+{
+    ImageCacheItem *item = cache->hash_table[id % IMAGE_CACHE_HASH_SIZE];
+
+    while (item) {
+        if (item->id == id) {
+            return item;
+        }
+        item = item->next;
+    }
+    return NULL;
+}
+
+static int image_cache_hit(ImageCache *cache, UINT64 id)
+{
+    ImageCacheItem *item;
+    if (!(item = image_cache_find(cache, id))) {
+        return FALSE;
+    }
+#ifdef IMAGE_CACHE_AGE
+    item->age = cache->age;
+#endif
+    ring_remove(&item->lru_link);
+    ring_add(&cache->lru, &item->lru_link);
+    return TRUE;
+}
+
+static void image_cache_remove(ImageCache *cache, ImageCacheItem *item)
+{
+    ImageCacheItem **now;
+
+    now = &cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
+    for (;;) {
+        ASSERT(*now);
+        if (*now == item) {
+            *now = item->next;
+            break;
+        }
+        now = &(*now)->next;
+    }
+    ring_remove(&item->lru_link);
+    cairo_surface_destroy(item->surf);
+    free(item);
+#ifndef IMAGE_CACHE_AGE
+    cache->num_items--;
+#endif
+}
+
+#define IMAGE_CACHE_MAX_ITEMS 2
+
+static void image_cache_put(void *opaque, uint64_t id, cairo_surface_t *surface)
+{
+    ImageCache *cache = (ImageCache *)opaque;
+    ImageCacheItem *item;
+
+#ifndef IMAGE_CACHE_AGE
+    if (cache->num_items == IMAGE_CACHE_MAX_ITEMS) {
+        ImageCacheItem *tail = (ImageCacheItem *)ring_get_tail(&cache->lru);
+        ASSERT(tail);
+        image_cache_remove(cache, tail);
+    }
+#endif
+
+    if (!(item = (ImageCacheItem *)malloc(sizeof(ImageCacheItem)))) {
+        red_error("alloc failed");
+    }
+    item->id = id;
+#ifdef IMAGE_CACHE_AGE
+    item->age = cache->age;
+#else
+    cache->num_items++;
+#endif
+    item->surf = cairo_surface_reference(surface);
+    ring_item_init(&item->lru_link);
+
+    item->next = cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE];
+    cache->hash_table[item->id % IMAGE_CACHE_HASH_SIZE] = item;
+
+    ring_add(&cache->lru, &item->lru_link);
+}
+
+static cairo_surface_t *image_cache_get(void *opaque, uint64_t id)
+{
+    ImageCache *cache = (ImageCache *)opaque;
+
+    ImageCacheItem *item = image_cache_find(cache, id);
+    if (!item) {
+        red_error("not found");
+    }
+    return cairo_surface_reference(item->surf);
+}
+
+static void image_cache_init(ImageCache *cache)
+{
+    memset(cache->hash_table, 0, sizeof(cache->hash_table));
+    ring_init(&cache->lru);
+#ifdef IMAGE_CACHE_AGE
+    cache->age = 0;
+#else
+    cache->num_items = 0;
+#endif
+}
+
+static void image_cache_reset(ImageCache *cache)
+{
+    ImageCacheItem *item;
+
+    while ((item = (ImageCacheItem *)ring_get_head(&cache->lru))) {
+        image_cache_remove(cache, item);
+    }
+#ifdef IMAGE_CACHE_AGE
+    cache->age = 0;
+#endif
+}
+
+#define IMAGE_CACHE_DEPTH 4
+
+static void image_cache_eaging(ImageCache *cache)
+{
+#ifdef IMAGE_CACHE_AGE
+    ImageCacheItem *item;
+
+    cache->age++;
+    while ((item = (ImageCacheItem *)ring_get_tail(&cache->lru)) &&
+           cache->age - item->age > IMAGE_CACHE_DEPTH) {
+        image_cache_remove(cache, item);
+    }
+#endif
+}
+
+static void localize_bitmap(RedWorker *worker, PHYSICAL *in_bitmap, long phys_delta)
+{
+    QXLImage *image;
+    QXLImage *local_image;
+
+    ASSERT(in_bitmap && *in_bitmap);
+    image = (QXLImage *)(*in_bitmap + phys_delta);
+    local_image = (QXLImage *)alloc_local_image(worker);
+    *local_image = *image;
+    *in_bitmap = (PHYSICAL)local_image;
+    local_image->descriptor.flags = 0;
+
+    if (image_cache_hit(&worker->image_cache, local_image->descriptor.id)) {
+        local_image->descriptor.type = IMAGE_TYPE_FROM_CACHE;
+        return;
+    }
+
+    switch (local_image->descriptor.type) {
+    case IMAGE_TYPE_QUIC: {
+        QXLDataChunk **chanks_head;
+#ifdef IMAGE_CACHE_AGE
+        local_image->descriptor.flags |= IMAGE_CACHE_ME;
+#else
+        if (local_image->descriptor.width * local_image->descriptor.height >= 640 * 480) {
+            local_image->descriptor.flags |= IMAGE_CACHE_ME;
+        }
+#endif
+        chanks_head = (QXLDataChunk **)local_image->quic.data;
+        *chanks_head = (QXLDataChunk *)image->quic.data;
+        break;
+    }
+    case IMAGE_TYPE_BITMAP:
+        if (image->bitmap.flags & QXL_BITMAP_DIRECT) {
+            local_image->bitmap.data = (PHYSICAL)(image->bitmap.data + phys_delta);
+        } else {
+            PHYSICAL src_data;
+            int size = image->bitmap.y * image->bitmap.stride;
+            uint8_t *data = malloc(size);
+            ASSERT(data);
+            local_image->bitmap.data = (PHYSICAL)data;
+            src_data = image->bitmap.data;
+
+            while (size) {
+                QXLDataChunk *chunk;
+                int cp_size;
+
+                ASSERT(src_data);
+                chunk = (QXLDataChunk *)(src_data + phys_delta);
+                cp_size = MIN(chunk->data_size, size);
+                memcpy(data, chunk->data, cp_size);
+                data += cp_size;
+                size -= cp_size;
+                src_data = chunk->next_chunk;
+            }
+        }
+
+        if (local_image->bitmap.palette) {
+            local_image->bitmap.palette = (local_image->bitmap.palette + phys_delta);
+        }
+        break;
+    default:
+        red_error("invalid image type");
+    }
+}
+
+static void unlocalize_bitmap(PHYSICAL *bitmap)
+{
+    QXLImage *image;
+
+    ASSERT(bitmap && *bitmap);
+    image = (QXLImage *)*bitmap;
+    *bitmap = 0;
+
+    switch (image->descriptor.type) {
+    case IMAGE_TYPE_BITMAP:
+        if (!(image->bitmap.flags & QXL_BITMAP_DIRECT)) {
+            free((void *)image->bitmap.data);
+        }
+        break;
+    case IMAGE_TYPE_QUIC:
+    case IMAGE_TYPE_FROM_CACHE:
+        *bitmap = 0;
+        break;
+    default:
+        red_error("invalid image type %u", image->descriptor.type);
+    }
+}
+
+static void localize_brush(RedWorker *worker, Brush *brush, long phys_delta)
+{
+    if (brush->type == BRUSH_TYPE_PATTERN) {
+        localize_bitmap(worker, &brush->u.pattern.pat, phys_delta);
+    }
+}
+
+static void unlocalize_brush(Brush *brush)
+{
+    if (brush->type == BRUSH_TYPE_PATTERN) {
+        unlocalize_bitmap(&brush->u.pattern.pat);
+    }
+}
+
+static void localize_mask(RedWorker *worker, QMask *mask, long phys_delta)
+{
+    if (mask->bitmap) {
+        localize_bitmap(worker, &mask->bitmap, phys_delta);
+    }
+}
+
+static void unlocalize_mask(QMask *mask)
+{
+    if (mask->bitmap) {
+        unlocalize_bitmap(&mask->bitmap);
+    }
+}
+
+static void localize_attr(LineAttr *attr, long phys_delta)
+{
+    if (attr->style_nseg) {
+        uint8_t *buf;
+        uint8_t *data;
+
+        ASSERT(attr->style);
+        buf = (uint8_t *)(attr->style + phys_delta);
+        data = malloc(attr->style_nseg * sizeof(uint32_t));
+        ASSERT(data);
+        memcpy(data, buf, attr->style_nseg * sizeof(uint32_t));
+        attr->style = (PHYSICAL)data;
+    }
+}
+
+static void unlocalize_attr(LineAttr *attr)
+{
+    if (attr->style_nseg) {
+        free((void *)attr->style);
+        attr->style = 0;
+    }
+}
+
+static void red_draw_qxl_drawable(RedWorker *worker, QXLDrawable *drawable)
+{
+    Clip clip = drawable->clip;
+
+    worker->local_images_pos = 0;
+    image_cache_eaging(&worker->image_cache);
+
+    worker->draw_context.set_access_params(worker->draw_context.canvas,
+                                           worker->dev_info.phys_delta);    // todo: use delta
+                                                                            //       instead of
+                                                                            //       localize_x
+    localize_clip(&clip, worker->dev_info.phys_delta);
+    switch (drawable->type) {
+    case QXL_DRAW_FILL: {
+        Fill fill = drawable->u.fill;
+        localize_brush(worker, &fill.brush, worker->dev_info.phys_delta);
+        localize_mask(worker, &fill.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_fill(worker->draw_context.canvas, &drawable->bbox, &clip, &fill);
+        unlocalize_mask(&fill.mask);
+        unlocalize_brush(&fill.brush);
+        break;
+    }
+    case QXL_DRAW_OPAQUE: {
+        Opaque opaque = drawable->u.opaque;
+        localize_brush(worker, &opaque.brush, worker->dev_info.phys_delta);
+        localize_bitmap(worker, &opaque.src_bitmap, worker->dev_info.phys_delta);
+        localize_mask(worker, &opaque.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_opaque(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                         &opaque);
+        unlocalize_mask(&opaque.mask);
+        unlocalize_bitmap(&opaque.src_bitmap);
+        unlocalize_brush(&opaque.brush);
+        break;
+    }
+    case QXL_DRAW_COPY: {
+        Copy copy = drawable->u.copy;
+        localize_bitmap(worker, &copy.src_bitmap, worker->dev_info.phys_delta);
+        localize_mask(worker, &copy.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_copy(worker->draw_context.canvas, &drawable->bbox, &clip, &copy);
+        unlocalize_mask(&copy.mask);
+        unlocalize_bitmap(&copy.src_bitmap);
+        break;
+    }
+    case QXL_DRAW_TRANSPARENT: {
+        Transparent transparent = drawable->u.transparent;
+        localize_bitmap(worker, &transparent.src_bitmap, worker->dev_info.phys_delta);
+        worker->draw_context.draw_transparent(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                              &transparent);
+        unlocalize_bitmap(&transparent.src_bitmap);
+        break;
+    }
+    case QXL_DRAW_ALPHA_BLEND: {
+        AlphaBlnd alpha_blend = drawable->u.alpha_blend;
+        localize_bitmap(worker, &alpha_blend.src_bitmap, worker->dev_info.phys_delta);
+        worker->draw_context.draw_alpha_blend(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                              &alpha_blend);
+        unlocalize_bitmap(&alpha_blend.src_bitmap);
+        break;
+    }
+    case QXL_COPY_BITS: {
+        worker->draw_context.copy_bits(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                       &drawable->u.copy_bits.src_pos);
+        break;
+    }
+    case QXL_DRAW_BLEND: {
+        Blend blend = drawable->u.blend;
+        localize_bitmap(worker, &blend.src_bitmap, worker->dev_info.phys_delta);
+        localize_mask(worker, &blend.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_blend(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                        &blend);
+        unlocalize_mask(&blend.mask);
+        unlocalize_bitmap(&blend.src_bitmap);
+        break;
+    }
+    case QXL_DRAW_BLACKNESS: {
+        Blackness blackness = drawable->u.blackness;
+        localize_mask(worker, &blackness.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_blackness(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                            &blackness);
+        unlocalize_mask(&blackness.mask);
+        break;
+    }
+    case QXL_DRAW_WHITENESS: {
+        Whiteness whiteness = drawable->u.whiteness;
+        localize_mask(worker, &whiteness.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_whiteness(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                            &whiteness);
+        unlocalize_mask(&whiteness.mask);
+        break;
+    }
+    case QXL_DRAW_INVERS: {
+        Invers invers = drawable->u.invers;
+        localize_mask(worker, &invers.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_invers(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                         &invers);
+        unlocalize_mask(&invers.mask);
+        break;
+    }
+    case QXL_DRAW_ROP3: {
+        Rop3 rop3 = drawable->u.rop3;
+        localize_brush(worker, &rop3.brush, worker->dev_info.phys_delta);
+        localize_bitmap(worker, &rop3.src_bitmap, worker->dev_info.phys_delta);
+        localize_mask(worker, &rop3.mask, worker->dev_info.phys_delta);
+        worker->draw_context.draw_rop3(worker->draw_context.canvas, &drawable->bbox, &clip, &rop3);
+        unlocalize_mask(&rop3.mask);
+        unlocalize_bitmap(&rop3.src_bitmap);
+        unlocalize_brush(&rop3.brush);
+        break;
+    }
+    case QXL_DRAW_STROKE: {
+        Stroke stroke = drawable->u.stroke;
+        localize_brush(worker, &stroke.brush, worker->dev_info.phys_delta);
+        localize_path(&stroke.path, worker->dev_info.phys_delta);
+        localize_attr(&stroke.attr, worker->dev_info.phys_delta);
+        worker->draw_context.draw_stroke(worker->draw_context.canvas, &drawable->bbox, &clip,
+                                         &stroke);
+        unlocalize_attr(&stroke.attr);
+        unlocalize_path(&stroke.path);
+        unlocalize_brush(&stroke.brush);
+        break;
+    }
+    case QXL_DRAW_TEXT: {
+        Text text = drawable->u.text;
+        localize_brush(worker, &text.fore_brush, worker->dev_info.phys_delta);
+        localize_brush(worker, &text.back_brush, worker->dev_info.phys_delta);
+        localize_str(&text.str, worker->dev_info.phys_delta);
+        worker->draw_context.draw_text(worker->draw_context.canvas, &drawable->bbox, &clip, &text);
+        unlocalize_str(&text.str);
+        unlocalize_brush(&text.back_brush);
+        unlocalize_brush(&text.fore_brush);
+        break;
+    }
+    default:
+        red_printf("invlaid type");
+    }
+    unlocalize_clip(&clip);
+}
+
+#ifndef DRAW_ALL
+
+static void red_draw_drawable(RedWorker *worker, Drawable *drawable)
+{
+#ifdef UPDATE_AREA_BY_TREE
+    //todo: add need top mask flag
+    worker->draw_context.set_top_mask(worker->draw_context.canvas,
+                                      drawable->tree_item.base.rgn.num_rects,
+                                      drawable->tree_item.base.rgn.rects);
+#endif
+    red_draw_qxl_drawable(worker, drawable->qxl_drawable);
+#ifdef UPDATE_AREA_BY_TREE
+    worker->draw_context.clear_top_mask(worker->draw_context.canvas);
+#endif
+}
+
+#ifdef UPDATE_AREA_BY_TREE
+
+static inline void __red_collect_for_update(RedWorker *worker, Ring *ring, RingItem *ring_item,
+                                            QRegion *rgn, Ring *items)
+{
+    Ring *top_ring = ring;
+
+    for (;;) {
+        TreeItem *now = CONTAINEROF(ring_item, TreeItem, siblings_link);
+        Container *container = now->container;
+        if (region_intersects(rgn, &now->rgn)) {
+            if (IS_DRAW_ITEM(now)) {
+                Drawable *drawable = CONTAINEROF(now, Drawable, tree_item);
+
+                ring_add(items, &drawable->collect_link);
+                region_or(rgn, &now->rgn);
+                if (drawable->tree_item.shadow) {
+                    region_or(rgn, &drawable->tree_item.shadow->base.rgn);
+                }
+            } else if (now->type == TREE_ITEM_TYPE_SHADOW) {
+                Drawable *owner = CONTAINEROF(((Shadow *)now)->owner, Drawable, tree_item);
+                if (!ring_item_is_linked(&owner->collect_link)) {
+                    region_or(rgn, &now->rgn);
+                    region_or(rgn, &owner->tree_item.base.rgn);
+                    ring_add(items, &owner->collect_link);
+                }
+            } else if (now->type == TREE_ITEM_TYPE_CONTAINER) {
+                Container *container = (Container *)now;
+
+                if ((ring_item = ring_get_head(&container->items))) {
+                    ring = &container->items;
+                    ASSERT(((TreeItem *)ring_item)->container);
+                    continue;
+                }
+                ring_item = &now->siblings_link;
+            }
+        }
+
+        while (!(ring_item = ring_next(ring, ring_item))) {
+            if (ring == top_ring) {
+                return;
+            }
+            ring_item = &container->base.siblings_link;
+            container = container->base.container;
+            ring = (container) ? &container->items : top_ring;
+        }
+    }
+}
+
+static void red_update_area(RedWorker *worker, const Rect *area)
+{
+    Ring *ring = &worker->current;
+    RingItem *ring_item;
+    Ring items;
+    QRegion rgn;
+
+    if (!(ring_item = ring_get_head(ring))) {
+        return;
+    }
+
+    region_init(&rgn);
+    region_add(&rgn, area);
+    ring_init(&items);
+    __red_collect_for_update(worker, ring, ring_item, &rgn, &items);
+    region_destroy(&rgn);
+
+    while ((ring_item = ring_get_head(&items))) {
+        Drawable *drawable = CONTAINEROF(ring_item, Drawable, collect_link);
+        Container *container;
+
+        ring_remove(ring_item);
+        red_draw_drawable(worker, drawable);
+        container = drawable->tree_item.base.container;
+        current_remove_drawable(worker, drawable);
+        container_cleanup(worker, container);
+    }
+    worker->draw_context.validate_area(worker->draw_context.canvas, &worker->dev_info.draw_area,
+                                       area);
+}
+
+#else
+
+static void red_update_area(RedWorker *worker, const Rect *area)
+{
+    Ring *ring = &worker->current_list;
+    RingItem *ring_item = ring;
+    QRegion rgn;
+    Drawable *last = NULL;
+    Drawable *now;
+
+    region_init(&rgn);
+    region_add(&rgn, area);
+    while ((ring_item = ring_next(ring, ring_item))) {
+        now = CONTAINEROF(ring_item, Drawable, list_link);
+        if (region_intersects(&rgn, &now->tree_item.base.rgn)) {
+            last = now;
+            break;
+        }
+    }
+    region_destroy(&rgn);
+
+    if (!last) {
+        return;
+    }
+
+    do {
+        Container *container;
+
+        ring_item = ring_get_tail(&worker->current_list);
+        now = CONTAINEROF(ring_item, Drawable, list_link);
+        red_draw_drawable(worker, now);
+        container = now->tree_item.base.container;
+        current_remove_drawable(worker, now);
+        container_cleanup(worker, container);
+    } while (now != last);
+    worker->draw_context.validate_area(worker->draw_context.canvas, &worker->dev_info.draw_area,
+                                       area);
+}
+
+#endif
+
+#endif
+
+static void red_release_cursor(RedWorker *worker, CursorItem *cursor)
+{
+    if (!--cursor->refs) {
+        QXLCursorCmd *cursor_cmd;
+
+        if (cursor->type == CURSOR_TYPE_LOCAL) {
+            free(cursor);
+            return;
+        }
+        cursor_cmd = CONTAINEROF(cursor, QXLCursorCmd, device_data);
+        worker->qxl->release_resource(worker->qxl, &cursor_cmd->release_info);
+    }
+}
+
+static void red_set_cursor(RedWorker *worker, CursorItem *cursor)
+{
+    if (worker->cursor) {
+        red_release_cursor(worker, worker->cursor);
+    }
+    ++cursor->refs;
+    worker->cursor = cursor;
+}
+
+void qxl_process_cursor(RedWorker *worker, QXLCursorCmd *cursor_cmd)
+{
+    CursorItem *item = (CursorItem *)cursor_cmd->device_data;
+    int cursor_show = FALSE;
+
+    red_pipe_item_init(&item->pipe_data, PIPE_ITEM_TYPE_CURSOR);
+    item->refs = 1;
+    item->type = CURSOR_TYPE_INVALID;
+
+    switch (cursor_cmd->type) {
+    case QXL_CURSOR_SET:
+        worker->cursor_visible = cursor_cmd->u.set.visible;
+        item->type = CURSOR_TYPE_DEV;
+        red_set_cursor(worker, item);
+        break;
+    case QXL_CURSOR_MOVE:
+        cursor_show = !worker->cursor_visible;
+        worker->cursor_visible = TRUE;
+        worker->cursor_position = cursor_cmd->u.position;
+        break;
+    case QXL_CURSOR_HIDE:
+        worker->cursor_visible = FALSE;
+        break;
+    case QXL_CURSOR_TRAIL:
+        worker->cursor_trail_length = cursor_cmd->u.trail.length;
+        worker->cursor_trail_frequency = cursor_cmd->u.trail.frequency;
+        break;
+    default:
+        red_error("invalid cursor command %u", cursor_cmd->type);
+    }
+
+    if (worker->cursor_channel && (worker->mouse_mode == RED_MOUSE_MODE_SERVER ||
+                                   cursor_cmd->type != QXL_CURSOR_MOVE || cursor_show)) {
+        red_pipe_add(&worker->cursor_channel->base, &item->pipe_data);
+    } else {
+        red_release_cursor(worker, item);
+    }
+}
+
+static inline uint64_t red_now()
+{
+    struct timespec time;
+
+    clock_gettime(CLOCK_MONOTONIC, &time);
+
+    return time.tv_sec * 1000000000 + time.tv_nsec;
+}
+
+static int red_process_cursor(RedWorker *worker, uint32_t max_pipe_size)
+{
+    QXLCommand cmd;
+    int n = 0;
+
+    while (!worker->cursor_channel || worker->cursor_channel->base.pipe_size <= max_pipe_size) {
+        if (!worker->qxl->get_cursor_command(worker->qxl, &cmd)) {
+            if (worker->repoll_cursor_ring < CMD_RING_POLL_RETRIES) {
+                worker->repoll_cursor_ring++;
+                worker->epoll_timeout = MIN(worker->epoll_timeout, CMD_RING_POLL_TIMEOUT);
+                break;
+            }
+            if (worker->repoll_cursor_ring > CMD_RING_POLL_RETRIES ||
+                worker->qxl->req_cursor_notification(worker->qxl)) {
+                worker->repoll_cursor_ring++;
+                break;
+            }
+            continue;
+        }
+        worker->repoll_cursor_ring = 0;
+        switch (cmd.type) {
+        case QXL_CMD_CURSOR: {
+            QXLCursorCmd *cursor_cmd = (QXLCursorCmd *)(cmd.data + worker->dev_info.phys_delta);
+            ASSERT((uint64_t)cursor_cmd >= worker->dev_info.phys_start);
+            ASSERT((uint64_t)cursor_cmd + sizeof(QXLCursorCmd) <= worker->dev_info.phys_end);
+            qxl_process_cursor(worker, cursor_cmd);
+            break;
+        }
+        default:
+            red_error("bad command type");
+        }
+        n++;
+    }
+    return n;
+}
+
+static int red_process_commands(RedWorker *worker, uint32_t max_pipe_size)
+{
+    QXLCommand cmd;
+    int n = 0;
+    uint64_t start = red_now();
+
+    while (!worker->display_channel || worker->display_channel->base.pipe_size <= max_pipe_size) {
+        if (!worker->qxl->get_command(worker->qxl, &cmd)) {
+            if (worker->repoll_cmd_ring < CMD_RING_POLL_RETRIES) {
+                worker->repoll_cmd_ring++;
+                worker->epoll_timeout = MIN(worker->epoll_timeout, CMD_RING_POLL_TIMEOUT);
+                break;
+            }
+            if (worker->repoll_cmd_ring > CMD_RING_POLL_RETRIES ||
+                         worker->qxl->req_cmd_notification(worker->qxl)) {
+                worker->repoll_cmd_ring++;
+                break;
+            }
+            continue;
+        }
+        stat_inc_counter(worker->command_counter, 1);
+        worker->repoll_cmd_ring = 0;
+        switch (cmd.type) {
+        case QXL_CMD_DRAW: {
+            QXLDrawable *drawable = (QXLDrawable *)(cmd.data + worker->dev_info.phys_delta);
+            ASSERT((uint64_t)drawable >= worker->dev_info.phys_start);
+            ASSERT((uint64_t)drawable + sizeof(QXLDrawable) <= worker->dev_info.phys_end);
+            red_process_drawable(worker, drawable);
+            break;
+        }
+        case QXL_CMD_UPDATE: {
+            QXLUpdateCmd *draw_cmd = (QXLUpdateCmd *)(cmd.data + worker->dev_info.phys_delta);
+            ASSERT((uint64_t)draw_cmd >= worker->dev_info.phys_start);
+            ASSERT((uint64_t)draw_cmd + sizeof(QXLUpdateCmd) <= worker->dev_info.phys_end);
+            red_update_area(worker, &draw_cmd->area);
+            worker->qxl->notify_update(worker->qxl, draw_cmd->update_id);
+            worker->qxl->release_resource(worker->qxl, &draw_cmd->release_info);
+            break;
+        }
+        case QXL_CMD_CURSOR: {
+            QXLCursorCmd *cursor_cmd = (QXLCursorCmd *)(cmd.data + worker->dev_info.phys_delta);
+            ASSERT((uint64_t)cursor_cmd >= worker->dev_info.phys_start);
+            ASSERT((uint64_t)cursor_cmd + sizeof(QXLCursorCmd) <= worker->dev_info.phys_end);
+            qxl_process_cursor(worker, cursor_cmd);
+            break;
+        }
+        case QXL_CMD_MESSAGE: {
+            QXLMessage *message = (QXLMessage *)(cmd.data + worker->dev_info.phys_delta);
+            ASSERT((uint64_t)message >= worker->dev_info.phys_start);
+            ASSERT((uint64_t)message + sizeof(QXLDrawable) <= worker->dev_info.phys_end);
+            red_printf("MESSAGE: %s", message->data);
+            worker->qxl->release_resource(worker->qxl, &message->release_info);
+            break;
+        }
+        default:
+            red_error("bad command type");
+        }
+        n++;
+        if ((worker->display_channel && worker->display_channel->base.send_data.blocked) ||
+                                                            red_now() - start > 10 * 1000 * 1000) {
+            worker->epoll_timeout = 0;
+            return n;
+        }
+    }
+    return n;
+}
+
+#define RED_RELEASE_BUNCH_SIZE 5
+
+static void red_free_some(RedWorker *worker)
+{
+    int n = 0;
+
+    if (worker->display_channel && worker->display_channel->glz_dict) {
+        // encoding using the dictionary is prevented since the following operations might
+        // change the dictionary
+        pthread_rwlock_wrlock(&worker->display_channel->glz_dict->encode_lock);
+        n = red_display_free_some_independent_glz_drawables(worker->display_channel);
+    }
+
+    while (!ring_is_empty(&worker->current_list) && n++ < RED_RELEASE_BUNCH_SIZE) {
+        free_one_drawable(worker, TRUE);
+    }
+
+    if (worker->display_channel && worker->display_channel->glz_dict) {
+        pthread_rwlock_unlock(&worker->display_channel->glz_dict->encode_lock);
+    }
+}
+
+static void red_current_flush(RedWorker *worker)
+{
+    while (!ring_is_empty(&worker->current_list)) {
+        free_one_drawable(worker, FALSE);
+    }
+    red_current_clear(worker);
+}
+
+static void red_add_screen_image(RedWorker *worker)
+{
+    ImageItem *item;
+    int stride;
+    Rect area;
+
+    if (!worker->display_channel) {
+        return;
+    }
+    stride = worker->dev_info.x_res << 2;
+    if (!(item = (ImageItem *)malloc(sizeof(ImageItem) + worker->dev_info.y_res * stride))) {
+        //warn
+        return;
+    }
+
+    red_pipe_item_init(&item->link, PIPE_ITEM_TYPE_IMAGE);
+
+    item->refs = 1;
+    item->pos.x = item->pos.y = 0;
+    item->width = worker->dev_info.x_res;
+    item->height = worker->dev_info.y_res;
+    item->stride = stride;
+    item->top_down = worker->draw_context.top_down;
+
+    area.top = area.left = 0;
+    area.right = worker->dev_info.x_res;
+    area.bottom = worker->dev_info.y_res;
+    worker->draw_context.read_pixels(worker->draw_context.canvas, item->data, stride, &area);
+    red_pipe_add_image_item(worker, item);
+    release_image_item(item);
+    display_channel_push(worker);
+}
+
+static void inline __add_buf(RedChannel *channel, uint32_t type, void *data, uint32_t size)
+{
+    int pos = channel->send_data.n_bufs++;
+    ASSERT(pos < MAX_SEND_BUFS);
+    channel->send_data.bufs[pos].type = type;
+    channel->send_data.bufs[pos].size = size;
+    channel->send_data.bufs[pos].data = data;
+}
+
+static void add_buf(RedChannel *channel, uint32_t type, void *data, uint32_t size)
+{
+    __add_buf(channel, type, data, size);
+    channel->send_data.header.size += size;
+}
+
+static void fill_path(DisplayChannel *display_channel, PHYSICAL *in_path)
+{
+    RedChannel *channel = &display_channel->base;
+    ASSERT(in_path && *in_path);
+    QXLPath *path = (QXLPath *)(*in_path + channel->worker->dev_info.phys_delta);
+    *in_path = channel->send_data.header.size;
+    add_buf(channel, BUF_TYPE_RAW, &path->data_size, sizeof(UINT32));
+    add_buf(channel, BUF_TYPE_CHUNK, &path->chunk, path->data_size);
+}
+
+static void fill_str(DisplayChannel *display_channel, PHYSICAL *in_str)
+{
+    RedChannel *channel = &display_channel->base;
+    ASSERT(in_str && *in_str);
+    QXLString *str = (QXLString *)(*in_str + channel->worker->dev_info.phys_delta);
+    *in_str = channel->send_data.header.size;
+    add_buf(channel, BUF_TYPE_RAW, &str->length, sizeof(UINT32));
+    add_buf(channel, BUF_TYPE_CHUNK, &str->chunk, str->data_size);
+}
+
+static inline void fill_rects_clip(RedChannel *channel, PHYSICAL *in_clip)
+{
+    QXLClipRects *clip;
+
+    ASSERT(in_clip && *in_clip);
+    clip = (QXLClipRects *)(*in_clip + channel->worker->dev_info.phys_delta);
+    *in_clip = channel->send_data.header.size;
+    add_buf(channel, BUF_TYPE_RAW, &clip->num_rects, sizeof(UINT32));
+    add_buf(channel, BUF_TYPE_CHUNK, &clip->chunk, clip->num_rects * sizeof(Rect));
+}
+
+static void fill_base(DisplayChannel *display_channel, RedDrawBase *base, QXLDrawable *drawable,
+                      uint32_t size)
+{
+    RedChannel *channel = &display_channel->base;
+    add_buf(channel, BUF_TYPE_RAW, base, size);
+    base->box = drawable->bbox;
+    base->clip = drawable->clip;
+
+    if (base->clip.type == CLIP_TYPE_RECTS) {
+        fill_rects_clip(channel, &base->clip.data);
+    } else if (base->clip.type == CLIP_TYPE_PATH) {
+        fill_path(display_channel, &base->clip.data);
+    }
+}
+
+static inline RedImage *alloc_image(DisplayChannel *display_channel)
+{
+    ASSERT(display_channel->send_data.bitmap_pos < MAX_BITMAPS);
+    return &display_channel->send_data.images[display_channel->send_data.bitmap_pos++];
+}
+
+/* io_palette is relative address of the palette*/
+static inline void fill_palette(DisplayChannel *display_channel, ADDRESS *io_palette, UINT8 *flags)
+{
+    RedChannel *channel = &display_channel->base;
+    Palette *palette;
+
+    if (!(*io_palette)) {
+        return;
+    }
+    palette = (Palette *)(*io_palette + channel->worker->dev_info.phys_delta);
+    if (palette->unique) {
+        if (red_palette_cache_find(display_channel, palette->unique)) {
+            *flags |= BITMAP_PAL_FROM_CACHE;
+            *io_palette = palette->unique;
+            return;
+        }
+        if (red_palette_cache_add(display_channel, palette->unique, 1)) {
+            *flags |= BITMAP_PAL_CACHE_ME;
+        }
+    }
+    *io_palette = channel->send_data.header.size;
+    add_buf(channel, BUF_TYPE_RAW, palette,
+            sizeof(Palette) + palette->num_ents * sizeof(UINT32));
+}
+
+static inline RedCompressBuf *red_display_alloc_compress_buf(DisplayChannel *display_channel)
+{
+    RedCompressBuf *ret;
+
+    if (display_channel->send_data.free_compress_bufs) {
+        ret = display_channel->send_data.free_compress_bufs;
+        display_channel->send_data.free_compress_bufs = ret->next;
+    } else {
+        if (!(ret = malloc(sizeof(*ret)))) {
+            return NULL;
+        }
+    }
+
+    ret->next = display_channel->send_data.used_compress_bufs;
+    display_channel->send_data.used_compress_bufs = ret;
+    return ret;
+}
+
+static inline void __red_display_free_compress_buf(DisplayChannel *display_channel,
+                                                   RedCompressBuf *buf)
+{
+    buf->next = display_channel->send_data.free_compress_bufs;
+    display_channel->send_data.free_compress_bufs = buf;
+}
+
+static void red_display_free_compress_buf(DisplayChannel *display_channel,
+                                          RedCompressBuf *buf)
+{
+    RedCompressBuf **curr_used = &display_channel->send_data.used_compress_bufs;
+
+    for (;;) {
+        ASSERT(*curr_used);
+        if (*curr_used == buf) {
+            *curr_used = buf->next;
+            break;
+        }
+        curr_used = &(*curr_used)->next;
+    }
+    __red_display_free_compress_buf(display_channel, buf);
+}
+
+static void red_display_reset_compress_buf(DisplayChannel *display_channel)
+{
+    while (display_channel->send_data.used_compress_bufs) {
+        RedCompressBuf *buf = display_channel->send_data.used_compress_bufs;
+        display_channel->send_data.used_compress_bufs = buf->next;
+        __red_display_free_compress_buf(display_channel, buf);
+    }
+}
+
+/******************************************************
+ *      Global lz red drawables routines
+*******************************************************/
+
+/* if already exists, returns it. Otherwise allocates and adds it (1) to the ring tail
+   in the channel (2) to the Drawable*/
+static RedGlzDrawable *red_display_get_glz_drawable(DisplayChannel *channel, Drawable *drawable)
+{
+    RedGlzDrawable *ret;
+
+    if (drawable->red_glz_drawable) {
+        return drawable->red_glz_drawable;
+    }
+
+    if (!(ret = malloc(sizeof(*ret)))) {
+        PANIC("malloc failed");
+    }
+
+    ret->display_channel = channel;
+    ret->qxl_drawable = drawable->qxl_drawable;
+    ret->drawable = drawable;
+    ret->instances_count = 0;
+    ring_init(&ret->instances);
+
+    ring_item_init(&ret->link);
+
+    ring_add_before(&ret->link, &channel->glz_drawables);
+    drawable->red_glz_drawable = ret;
+
+    return ret;
+}
+
+/* allocates new instance and adds it to instances in the given drawable.
+   NOTE - the caller should set the glz_instance returned by the encoder by itself.*/
+static GlzDrawableInstanceItem *red_display_add_glz_drawable_instance(RedGlzDrawable *glz_drawable)
+{
+    ASSERT(glz_drawable->instances_count < MAX_GLZ_DRAWABLE_INSTANCES);
+    // NOTE: We assume the addtions are performed consecutively, without removals in the middle
+    GlzDrawableInstanceItem *ret = glz_drawable->instances_pool + glz_drawable->instances_count;
+    glz_drawable->instances_count++;
+
+    ring_item_init(&ret->free_link);
+    ring_item_init(&ret->glz_link);
+    ring_add(&glz_drawable->instances, &ret->glz_link);
+    ret->glz_instance = NULL;
+    ret->red_glz_drawable = glz_drawable;
+
+    return ret;
+}
+
+/* Remove from the to_free list and the instances_list.
+   When no instance is left - the RedGlzDrawable is released too. (and the qxl drawblae too, if
+   it is not used by Drawable).
+   NOTE - 1) can be called only by the display channel that created the drawable
+          2) it is assumed that the instance was already removed from the dicitonary*/
+static void red_display_free_glz_drawable_instance(DisplayChannel *channel,
+                                                   GlzDrawableInstanceItem *glz_drawable_instance)
+{
+    RedGlzDrawable *glz_drawable;
+
+    ASSERT(glz_drawable_instance);
+    ASSERT(glz_drawable_instance->red_glz_drawable);
+
+    glz_drawable = glz_drawable_instance->red_glz_drawable;
+
+    ASSERT(glz_drawable->display_channel == channel);
+    ASSERT(glz_drawable->instances_count);
+
+    ring_remove(&glz_drawable_instance->glz_link);
+    glz_drawable->instances_count--;
+    // whan the remove callback is performed from the channel that the
+    // drawable belongs to, the instance is not added to the 'to_free' list
+    if (ring_item_is_linked(&glz_drawable_instance->free_link)) {
+        ring_remove(&glz_drawable_instance->free_link);
+    }
+
+    if (ring_is_empty(&glz_drawable->instances)) {
+        ASSERT(!glz_drawable->instances_count);
+
+        Drawable *drawable = glz_drawable->drawable;
+
+        if (drawable) {
+            drawable->red_glz_drawable = NULL;
+        } else { // no reference to the qxl drawable left
+            free_qxl_drawable(channel->base.worker, glz_drawable->qxl_drawable);
+        }
+
+        if (ring_item_is_linked(&glz_drawable->link)) {
+            ring_remove(&glz_drawable->link);
+        }
+        free(glz_drawable);
+    }
+}
+
+static void red_display_handle_glz_drawables_to_free(DisplayChannel* channel)
+{
+    RingItem *ring_link;
+    pthread_mutex_lock(&channel->glz_drawables_inst_to_free_lock);
+
+    while ((ring_link = ring_get_head(&channel->glz_drawables_inst_to_free))) {
+        GlzDrawableInstanceItem *drawable_instance = CONTAINEROF(ring_link,
+                                                                 GlzDrawableInstanceItem,
+                                                                 free_link);
+        red_display_free_glz_drawable_instance(channel, drawable_instance);
+    }
+
+    pthread_mutex_unlock(&channel->glz_drawables_inst_to_free_lock);
+}
+
+/* releases all the instances of the drawable from the dictionary and the display channel.
+   The release of the last instance will also release the drawable itself and the qxl drawable
+   if possible.
+   NOTE - the caller should prevent encoding using the dicitonary during this operation*/
+static void red_display_free_glz_drawable(DisplayChannel *channel, RedGlzDrawable *drawable)
+{
+    RingItem *head_instance = ring_get_head(&drawable->instances);
+    int cont = (head_instance != NULL);
+
+    while (cont) {
+        if (drawable->instances_count == 1) {
+            /* Last instance: red_display_free_glz_drawable_instance will free the drawable */
+            cont = FALSE;
+        }
+        GlzDrawableInstanceItem *instance = CONTAINEROF(head_instance,
+                                                        GlzDrawableInstanceItem,
+                                                        glz_link);
+        if (!ring_item_is_linked(&instance->free_link)) {
+            // the instance didn't get out from window yet
+            glz_enc_dictionary_remove_image(channel->glz_dict->dict,
+                                            instance->glz_instance,
+                                            &channel->glz_data.usr);
+        }
+        red_display_free_glz_drawable_instance(channel, instance);
+
+        if (cont) {
+            head_instance = ring_get_head(&drawable->instances);
+        }
+    }
+}
+
+/* Clear all lz drawables - enforce their removal from the global dictionary.
+   NOTE - prevents encoding using the dicitonary during the operation*/
+static void red_display_clear_glz_drawables(DisplayChannel *channel)
+{
+    RingItem *ring_link;
+
+    if (!channel || !channel->glz_dict) {
+        return;
+    }
+
+    // assure no display channel is during global lz encoding
+    pthread_rwlock_wrlock(&channel->glz_dict->encode_lock);
+
+    while ((ring_link = ring_get_head(&channel->glz_drawables))) {
+        RedGlzDrawable *drawable = CONTAINEROF(ring_link, RedGlzDrawable, link);
+        // no need to lock the to_free list, since we assured no other thread is encoding and
+        // thus not other thread access the to_free list of the channel
+        red_display_free_glz_drawable(channel, drawable);
+    }
+
+    pthread_rwlock_unlock(&channel->glz_dict->encode_lock);
+}
+
+/* Remove from the global lz dictionary some glz_drawables that have no reference to
+   Drawable (their qxl drawables are released too).
+   NOTE - the caller should prevent encoding using the dicitonary during the operation*/
+static int red_display_free_some_independent_glz_drawables(DisplayChannel *channel)
+{
+    int n = 0;
+
+    if (!channel) {
+        return 0;
+    }
+
+    RingItem *ring_link = ring_get_head(&channel->glz_drawables);
+
+    while ((n < RED_RELEASE_BUNCH_SIZE) && (ring_link != NULL)) {
+        RedGlzDrawable *glz_drawable = CONTAINEROF(ring_link, RedGlzDrawable, link);
+        ring_link = ring_next(&channel->glz_drawables, ring_link);
+        if (!glz_drawable->drawable) {
+            red_display_free_glz_drawable(channel, glz_drawable);
+            n++;
+        }
+    }
+    return n;
+}
+
+/******************************************************
+ *              Encoders callbacks
+*******************************************************/
+static void quic_usr_error(QuicUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((QuicData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+    red_printf("%s", usr_data->message_buf);
+
+    longjmp(usr_data->jmp_env, 1);
+}
+
+static void lz_usr_error(LzUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((LzData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+    red_printf("%s", usr_data->message_buf);
+
+    longjmp(usr_data->jmp_env, 1);
+}
+
+static void glz_usr_error(GlzEncoderUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((GlzData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+
+    PANIC(usr_data->message_buf); // if global lz fails in the middle
+                                  // the consequences are not predictable since the window
+                                  // can turn to be unsynchronized between the server and
+                                  // and the client
+}
+
+static void quic_usr_warn(QuicUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((QuicData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+    red_printf("%s", usr_data->message_buf);
+}
+
+static void lz_usr_warn(LzUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((LzData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+    red_printf("%s", usr_data->message_buf);
+}
+
+static void glz_usr_warn(GlzEncoderUsrContext *usr, const char *fmt, ...)
+{
+    EncoderData *usr_data = &(((GlzData *)usr)->data);
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsnprintf(usr_data->message_buf, sizeof(usr_data->message_buf), fmt, ap);
+    va_end(ap);
+    red_printf("%s", usr_data->message_buf);
+}
+
+static void *quic_usr_malloc(QuicUsrContext *usr, int size)
+{
+    return malloc(size);
+}
+
+static void *lz_usr_malloc(LzUsrContext *usr, int size)
+{
+    return malloc(size);
+}
+
+static void *glz_usr_malloc(GlzEncoderUsrContext *usr, int size)
+{
+    return malloc(size);
+}
+
+static void quic_usr_free(QuicUsrContext *usr, void *ptr)
+{
+    free(ptr);
+}
+
+static void lz_usr_free(LzUsrContext *usr, void *ptr)
+{
+    free(ptr);
+}
+
+static void glz_usr_free(GlzEncoderUsrContext *usr, void *ptr)
+{
+    free(ptr);
+}
+
+static inline int encoder_usr_more_space(EncoderData *enc_data, uint32_t **io_ptr)
+{
+    RedCompressBuf *buf;
+
+    if (!(buf = red_display_alloc_compress_buf(enc_data->display_channel))) {
+        return 0;
+    }
+    enc_data->bufs_tail->send_next = buf;
+    enc_data->bufs_tail = buf;
+    buf->send_next = NULL;
+    *io_ptr = buf->buf;
+    return sizeof(buf->buf) >> 2;
+}
+
+static int quic_usr_more_space(QuicUsrContext *usr, uint32_t **io_ptr, int rows_completed)
+{
+    EncoderData *usr_data = &(((QuicData *)usr)->data);
+    return encoder_usr_more_space(usr_data, io_ptr);
+}
+
+static int lz_usr_more_space(LzUsrContext *usr, uint8_t **io_ptr)
+{
+    EncoderData *usr_data = &(((LzData *)usr)->data);
+    return (encoder_usr_more_space(usr_data, (uint32_t **)io_ptr) << 2);
+}
+
+static int glz_usr_more_space(GlzEncoderUsrContext *usr, uint8_t **io_ptr)
+{
+    EncoderData *usr_data = &(((GlzData *)usr)->data);
+    return (encoder_usr_more_space(usr_data, (uint32_t **)io_ptr) << 2);
+}
+
+static inline int encoder_usr_more_lines(EncoderData *enc_data, uint8_t **lines)
+{
+    if (!enc_data->u.lines_data.next) {
+        return 0;
+    }
+
+    QXLDataChunk *chunk = (QXLDataChunk *)(enc_data->u.lines_data.next +
+                                           enc_data->u.lines_data.address_delta);
+    if (chunk->data_size % enc_data->u.lines_data.stride) {
+        return 0;
+    }
+    enc_data->u.lines_data.next = chunk->next_chunk;
+    *lines = chunk->data;
+    return chunk->data_size / enc_data->u.lines_data.stride;
+}
+
+static int quic_usr_more_lines(QuicUsrContext *usr, uint8_t **lines)
+{
+    EncoderData *usr_data = &(((QuicData *)usr)->data);
+    return encoder_usr_more_lines(usr_data, lines);
+}
+
+static int lz_usr_more_lines(LzUsrContext *usr, uint8_t **lines)
+{
+    EncoderData *usr_data = &(((LzData *)usr)->data);
+    return encoder_usr_more_lines(usr_data, lines);
+}
+
+static int glz_usr_more_lines(GlzEncoderUsrContext *usr, uint8_t **lines)
+{
+    EncoderData *usr_data = &(((GlzData *)usr)->data);
+    return encoder_usr_more_lines(usr_data, lines);
+}
+
+static int quic_usr_more_lines_revers(QuicUsrContext *usr, uint8_t **lines)
+{
+    EncoderData *quic_data = &(((QuicData *)usr)->data);
+
+    if (!quic_data->u.lines_data.next) {
+        return 0;
+    }
+
+    QXLDataChunk *chunk = (QXLDataChunk *)(quic_data->u.lines_data.next +
+                                           quic_data->u.lines_data.address_delta);
+    if (chunk->data_size % quic_data->u.lines_data.stride) {
+        return 0;
+    }
+    quic_data->u.lines_data.next = chunk->prev_chunk;
+    *lines = chunk->data + chunk->data_size - quic_data->u.lines_data.stride;
+    return chunk->data_size / quic_data->u.lines_data.stride;
+}
+
+static int quic_usr_more_lines_unstable(QuicUsrContext *usr, uint8_t **out_lines)
+{
+    EncoderData *quic_data = &(((QuicData *)usr)->data);
+
+    if (!quic_data->u.unstable_lines_data.lines) {
+        return 0;
+    }
+    uint8_t *src = quic_data->u.unstable_lines_data.next;
+    int lines = MIN(quic_data->u.unstable_lines_data.lines,
+                    quic_data->u.unstable_lines_data.max_lines_bunch);
+    quic_data->u.unstable_lines_data.lines -= lines;
+    uint8_t *end = src + lines * quic_data->u.unstable_lines_data.src_stride;
+    quic_data->u.unstable_lines_data.next = end;
+
+    uint8_t *out = (uint8_t *)quic_data->u.unstable_lines_data.input_bufs[
+            quic_data->u.unstable_lines_data.input_bufs_pos++ & 1]->buf;
+    uint8_t *dest = out;
+    for (; src != end; src += quic_data->u.unstable_lines_data.src_stride,
+                       dest += quic_data->u.unstable_lines_data.dest_stride) {
+        memcpy(dest, src, quic_data->u.unstable_lines_data.dest_stride);
+    }
+    *out_lines = out;
+    return lines;
+}
+
+static int quic_usr_no_more_lines(QuicUsrContext *usr, uint8_t **lines)
+{
+    return 0;
+}
+
+static int lz_usr_no_more_lines(LzUsrContext *usr, uint8_t **lines)
+{
+    return 0;
+}
+
+static int glz_usr_no_more_lines(GlzEncoderUsrContext *usr, uint8_t **lines)
+{
+    return 0;
+}
+
+static void glz_usr_free_image(GlzEncoderUsrContext *usr, GlzUsrImageContext *image)
+{
+    GlzData *lz_data = (GlzData *)usr;
+    GlzDrawableInstanceItem *glz_drawable_instance = (GlzDrawableInstanceItem *)image;
+    DisplayChannel *drawable_channel = glz_drawable_instance->red_glz_drawable->display_channel;
+    DisplayChannel *this_channel = CONTAINEROF(lz_data, DisplayChannel, glz_data);
+    if (this_channel == drawable_channel) {
+        red_display_free_glz_drawable_instance(drawable_channel, glz_drawable_instance);
+    } else {
+        pthread_mutex_lock(&drawable_channel->glz_drawables_inst_to_free_lock);
+        ring_add_before(&glz_drawable_instance->free_link,
+                        &drawable_channel->glz_drawables_inst_to_free);
+        pthread_mutex_unlock(&drawable_channel->glz_drawables_inst_to_free_lock);
+    }
+}
+
+static inline void red_init_quic(RedWorker *worker)
+{
+    worker->quic_data.usr.error = quic_usr_error;
+    worker->quic_data.usr.warn = quic_usr_warn;
+    worker->quic_data.usr.info = quic_usr_warn;
+    worker->quic_data.usr.malloc = quic_usr_malloc;
+    worker->quic_data.usr.free = quic_usr_free;
+    worker->quic_data.usr.more_space = quic_usr_more_space;
+    worker->quic_data.usr.more_lines = quic_usr_more_lines;
+
+    worker->quic = quic_create(&worker->quic_data.usr);
+
+    if (!worker->quic) {
+        PANIC("create quic failed");
+    }
+}
+
+static inline void red_init_lz(RedWorker *worker)
+{
+    worker->lz_data.usr.error = lz_usr_error;
+    worker->lz_data.usr.warn = lz_usr_warn;
+    worker->lz_data.usr.info = lz_usr_warn;
+    worker->lz_data.usr.malloc = lz_usr_malloc;
+    worker->lz_data.usr.free = lz_usr_free;
+    worker->lz_data.usr.more_space = lz_usr_more_space;
+    worker->lz_data.usr.more_lines = lz_usr_more_lines;
+
+    worker->lz = lz_create(&worker->lz_data.usr);
+
+    if (!worker->lz) {
+        PANIC("create lz failed");
+    }
+}
+
+static inline void red_display_init_glz_data(DisplayChannel *display)
+{
+    display->glz_data.usr.error = glz_usr_error;
+    display->glz_data.usr.warn = glz_usr_warn;
+    display->glz_data.usr.info = glz_usr_warn;
+    display->glz_data.usr.malloc = glz_usr_malloc;
+    display->glz_data.usr.free = glz_usr_free;
+    display->glz_data.usr.more_space = glz_usr_more_space;
+    display->glz_data.usr.more_lines = glz_usr_more_lines;
+    display->glz_data.usr.free_image = glz_usr_free_image;
+}
+
+#ifdef __GNUC__
+#define ATTR_PACKED __attribute__ ((__packed__))
+#else
+#define ATTR_PACKED
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+
+typedef struct ATTR_PACKED rgb32_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+    uint8_t pad;
+} rgb32_pixel_t;
+
+typedef struct ATTR_PACKED rgb24_pixel_t {
+    uint8_t b;
+    uint8_t g;
+    uint8_t r;
+} rgb24_pixel_t;
+
+typedef uint16_t rgb16_pixel_t;
+
+#ifndef __GNUC__
+#pragma pack(pop)
+#endif
+
+#undef ATTR_PACKED
+
+#define RED_BITMAP_UTILS_RGB16
+#include "red_bitmap_utils.h"
+#define RED_BITMAP_UTILS_RGB24
+#include "red_bitmap_utils.h"
+#define RED_BITMAP_UTILS_RGB32
+#include "red_bitmap_utils.h"
+
+#define GRADUAL_SCORE_RGB24_TH -0.03
+#define GRADUAL_SCORE_RGB16_TH 0
+
+// assumes that stride doesn't overflow
+static int _bitmap_is_gradual(RedWorker *worker, Bitmap *bitmap)
+{
+    long address_delta = worker->dev_info.phys_delta;
+    double score = 0.0;
+    int num_samples = 0;
+
+    if ((bitmap->flags & QXL_BITMAP_DIRECT)) {
+        uint8_t *lines = (uint8_t*)(bitmap->data + address_delta);
+        switch (bitmap->format) {
+        case BITMAP_FMT_16BIT:
+            compute_lines_gradual_score_rgb16((rgb16_pixel_t*)lines, bitmap->x, bitmap->y,
+                                              &score, &num_samples);
+            break;
+        case BITMAP_FMT_24BIT:
+            compute_lines_gradual_score_rgb24((rgb24_pixel_t*)lines, bitmap->x, bitmap->y,
+                                              &score, &num_samples);
+            break;
+        case BITMAP_FMT_32BIT:
+        case BITMAP_FMT_RGBA:
+            compute_lines_gradual_score_rgb32((rgb32_pixel_t*)lines, bitmap->x, bitmap->y,
+                                              &score, &num_samples);
+            break;
+        default:
+            red_error("invalid bitmap format (not RGB) %u", bitmap->format);
+        }
+    } else {
+        QXLDataChunk *chunk = NULL;
+        int num_lines;
+        double chunk_score = 0.0;
+        int chunk_num_samples = 0;
+        ADDRESS relative_address = bitmap->data;
+
+        while (relative_address) {
+            chunk = (QXLDataChunk *)(relative_address + address_delta);
+            num_lines = chunk->data_size / bitmap->stride;
+            switch (bitmap->format) {
+            case BITMAP_FMT_16BIT:
+                compute_lines_gradual_score_rgb16((rgb16_pixel_t*)chunk->data, bitmap->x, num_lines,
+                                                  &chunk_score, &chunk_num_samples);
+                break;
+            case BITMAP_FMT_24BIT:
+                compute_lines_gradual_score_rgb24((rgb24_pixel_t*)chunk->data, bitmap->x, num_lines,
+                                                  &chunk_score, &chunk_num_samples);
+                break;
+            case BITMAP_FMT_32BIT:
+            case BITMAP_FMT_RGBA:
+                compute_lines_gradual_score_rgb32((rgb32_pixel_t*)chunk->data, bitmap->x, num_lines,
+                                                  &chunk_score, &chunk_num_samples);
+                break;
+            default:
+                red_error("invalid bitmap format (not RGB) %u", bitmap->format);
+            }
+
+            score += chunk_score;
+            num_samples += chunk_num_samples;
+
+            relative_address = chunk->next_chunk;
+        }
+    }
+
+    ASSERT(num_samples);
+    score /= num_samples;
+
+    if (bitmap->format == BITMAP_FMT_16BIT) {
+        return (score < GRADUAL_SCORE_RGB16_TH);
+    } else {
+        return (score < GRADUAL_SCORE_RGB24_TH);
+    }
+}
+
+static inline int _stride_is_extra(Bitmap *bitmap)
+{
+    ASSERT(bitmap);
+    if (BITMAP_FMT_IS_RGB[bitmap->format]) {
+        return ((bitmap->x * BITMAP_FMP_BYTES_PER_PIXEL[bitmap->format]) < bitmap->stride);
+    } else {
+        switch (bitmap->format) {
+        case BITMAP_FMT_8BIT:
+            return (bitmap->x < bitmap->stride);
+        case BITMAP_FMT_4BIT_BE:
+        case BITMAP_FMT_4BIT_LE: {
+            int bytes_width = ALIGN(bitmap->x, 2) >> 1;
+            return bytes_width < bitmap->stride;
+        }
+        case BITMAP_FMT_1BIT_BE:
+        case BITMAP_FMT_1BIT_LE: {
+            int bytes_width = ALIGN(bitmap->x, 8) >> 3;
+            return bytes_width < bitmap->stride;
+        }
+        default:
+            red_error("invalid image type %u", bitmap->format);
+        }
+    }
+}
+
+static const LzImageType MAP_BITMAP_FMT_TO_LZ_IMAGE_TYPE[] = {
+    LZ_IMAGE_TYPE_INVALID,
+    LZ_IMAGE_TYPE_PLT1_LE,
+    LZ_IMAGE_TYPE_PLT1_BE,
+    LZ_IMAGE_TYPE_PLT4_LE,
+    LZ_IMAGE_TYPE_PLT4_BE,
+    LZ_IMAGE_TYPE_PLT8,
+    LZ_IMAGE_TYPE_RGB16,
+    LZ_IMAGE_TYPE_RGB24,
+    LZ_IMAGE_TYPE_RGB32,
+    LZ_IMAGE_TYPE_RGBA
+};
+
+typedef struct compress_send_data_t {
+    uint32_t raw_size;
+    void*    comp_buf;
+    uint32_t comp_buf_size;
+    ADDRESS  *plt_ptr;
+    UINT8    *flags_ptr;
+} compress_send_data_t;
+
+
+static inline int red_glz_compress_image(DisplayChannel *display_channel,
+                                         RedImage *dest, Bitmap *src, Drawable *drawable,
+                                         compress_send_data_t* o_comp_data)
+{
+#ifdef COMPRESS_STAT
+    stat_time_t start_time = stat_now();
+#endif
+    ASSERT(BITMAP_FMT_IS_RGB[src->format]);
+    GlzData *glz_data = &display_channel->glz_data;
+    LzImageType type = MAP_BITMAP_FMT_TO_LZ_IMAGE_TYPE[src->format];
+    RedGlzDrawable *glz_drawable;
+    GlzDrawableInstanceItem *glz_drawable_instance;
+    uint8_t *lines;
+    unsigned int num_lines;
+    int size;
+    long address_delta;
+
+    glz_data->data.bufs_tail = red_display_alloc_compress_buf(display_channel);
+    glz_data->data.bufs_head = glz_data->data.bufs_tail;
+
+    if (!glz_data->data.bufs_head) {
+        return FALSE;
+    }
+
+    glz_data->data.bufs_head->send_next = NULL;
+    glz_data->data.display_channel = display_channel;
+    address_delta = display_channel->base.worker->dev_info.phys_delta;
+
+    glz_drawable = red_display_get_glz_drawable(display_channel, drawable);
+    glz_drawable_instance = red_display_add_glz_drawable_instance(glz_drawable);
+
+    if ((src->flags & QXL_BITMAP_DIRECT)) {
+        glz_data->usr.more_lines = glz_usr_no_more_lines;
+        lines = (uint8_t*)(src->data + address_delta);
+        num_lines = src->y;
+    } else {
+        glz_data->data.u.lines_data.address_delta = address_delta;
+        glz_data->data.u.lines_data.stride = src->stride;
+        glz_data->data.u.lines_data.next = src->data;
+        glz_data->usr.more_lines = glz_usr_more_lines;
+        lines = NULL;
+        num_lines = 0;
+    }
+
+    size = glz_encode(display_channel->glz, type, src->x, src->y,
+                      (src->flags & QXL_BITMAP_TOP_DOWN), lines, num_lines,
+                      src->stride, (uint8_t*)glz_data->data.bufs_head->buf,
+                      sizeof(glz_data->data.bufs_head->buf),
+                      glz_drawable_instance,
+                      &glz_drawable_instance->glz_instance);
+
+    dest->descriptor.type = IMAGE_TYPE_GLZ_RGB;
+    dest->lz_rgb.data_size = size;
+
+    o_comp_data->raw_size = sizeof(LZ_RGBImage);
+    o_comp_data->comp_buf = glz_data->data.bufs_head;
+    o_comp_data->comp_buf_size = size;
+    o_comp_data->plt_ptr = NULL;
+    o_comp_data->flags_ptr = NULL;
+
+    stat_compress_add(&display_channel->glz_stat, start_time, src->stride * src->y,
+                      o_comp_data->comp_buf_size);
+    return TRUE;
+}
+
+static inline int red_lz_compress_image(DisplayChannel *display_channel,
+                                        RedImage *dest, Bitmap *src,
+                                        compress_send_data_t* o_comp_data)
+{
+    RedWorker *worker = display_channel->base.worker;
+    LzData *lz_data = &worker->lz_data;
+    LzContext *lz = worker->lz;
+    LzImageType type = MAP_BITMAP_FMT_TO_LZ_IMAGE_TYPE[src->format];
+    long address_delta;
+    int size;            // size of the compressed data
+
+#ifdef COMPRESS_STAT
+    stat_time_t start_time = stat_now();
+#endif
+
+    lz_data->data.bufs_tail = red_display_alloc_compress_buf(display_channel);
+    lz_data->data.bufs_head = lz_data->data.bufs_tail;
+
+    if (!lz_data->data.bufs_head) {
+        return FALSE;
+    }
+
+    lz_data->data.bufs_head->send_next = NULL;
+    lz_data->data.display_channel = display_channel;
+    address_delta = worker->dev_info.phys_delta;
+
+    if (setjmp(lz_data->data.jmp_env)) {
+        while (lz_data->data.bufs_head) {
+            RedCompressBuf *buf = lz_data->data.bufs_head;
+            lz_data->data.bufs_head = buf->send_next;
+            red_display_free_compress_buf(display_channel, buf);
+        }
+        return FALSE;
+    }
+
+    if ((src->flags & QXL_BITMAP_DIRECT)) {
+        lz_data->usr.more_lines = lz_usr_no_more_lines;
+        size = lz_encode(lz, type, src->x, src->y, (src->flags & QXL_BITMAP_TOP_DOWN),
+                         (uint8_t*)(src->data + address_delta), src->y, src->stride,
+                         (uint8_t*)lz_data->data.bufs_head->buf,
+                         sizeof(lz_data->data.bufs_head->buf));
+    } else {
+        lz_data->data.u.lines_data.address_delta = address_delta;
+        lz_data->data.u.lines_data.stride = src->stride;
+        lz_data->data.u.lines_data.next = src->data;
+        lz_data->usr.more_lines = lz_usr_more_lines;
+
+        size = lz_encode(lz, type, src->x, src->y, (src->flags & QXL_BITMAP_TOP_DOWN),
+                         NULL, 0, src->stride,
+                         (uint8_t*)lz_data->data.bufs_head->buf,
+                         sizeof(lz_data->data.bufs_head->buf));
+    }
+
+    // the compressed buffer is bigger than the original data
+    if (size > (src->y * src->stride)) {
+        longjmp(lz_data->data.jmp_env, 1);
+    }
+
+    if (BITMAP_FMT_IS_RGB[src->format]) {
+        dest->descriptor.type = IMAGE_TYPE_LZ_RGB;
+        dest->lz_rgb.data_size = size;
+
+        o_comp_data->raw_size = sizeof(LZ_RGBImage);
+        o_comp_data->comp_buf = lz_data->data.bufs_head;
+        o_comp_data->comp_buf_size = size;
+        o_comp_data->plt_ptr = NULL;
+        o_comp_data->flags_ptr = NULL;
+    } else {
+        dest->descriptor.type = IMAGE_TYPE_LZ_PLT;
+        dest->lz_plt.data_size = size;
+        dest->lz_plt.flags = src->flags & BITMAP_TOP_DOWN;
+        dest->lz_plt.palette = src->palette;
+
+        o_comp_data->raw_size = sizeof(LZ_PLTImage);
+        o_comp_data->comp_buf = lz_data->data.bufs_head;
+        o_comp_data->comp_buf_size = size;
+        o_comp_data->plt_ptr = &(dest->lz_plt.palette);
+        o_comp_data->flags_ptr = &(dest->lz_plt.flags);
+    }
+    stat_compress_add(&display_channel->lz_stat, start_time, src->stride * src->y,
+                      o_comp_data->comp_buf_size);
+    return TRUE;
+}
+
+static inline int red_quic_compress_image(DisplayChannel *display_channel, RedImage *dest,
+                                          Bitmap *src, compress_send_data_t* o_comp_data)
+{
+    RedWorker *worker = display_channel->base.worker;
+    QuicData *quic_data = &worker->quic_data;
+    QuicContext *quic = worker->quic;
+    QuicImageType type;
+    long address_delta;
+    int size;
+
+#ifdef COMPRESS_STAT
+    stat_time_t start_time = stat_now();
+#endif
+
+    switch (src->format) {
+    case BITMAP_FMT_32BIT:
+        type = QUIC_IMAGE_TYPE_RGB32;
+        break;
+    case BITMAP_FMT_RGBA:
+        type = QUIC_IMAGE_TYPE_RGBA;
+        break;
+    case BITMAP_FMT_16BIT:
+        type = QUIC_IMAGE_TYPE_RGB16;
+        break;
+    case BITMAP_FMT_24BIT:
+        type = QUIC_IMAGE_TYPE_RGB24;
+        break;
+    default:
+        return FALSE;
+    }
+
+    quic_data->data.bufs_tail = red_display_alloc_compress_buf(display_channel);
+    quic_data->data.bufs_head = quic_data->data.bufs_tail;
+
+    if (!quic_data->data.bufs_head) {
+        return FALSE;
+    }
+
+    quic_data->data.bufs_head->send_next = NULL;
+    quic_data->data.display_channel = display_channel;
+    address_delta = worker->dev_info.phys_delta;
+
+    if (setjmp(quic_data->data.jmp_env)) {
+        while (quic_data->data.bufs_head) {
+            RedCompressBuf *buf = quic_data->data.bufs_head;
+            quic_data->data.bufs_head = buf->send_next;
+            red_display_free_compress_buf(display_channel, buf);
+        }
+        return FALSE;
+    }
+
+    if ((src->flags & QXL_BITMAP_DIRECT)) {
+        int stride;
+        uint8_t *data;
+
+        if (!(src->flags & QXL_BITMAP_TOP_DOWN)) {
+            data = (uint8_t*)(src->data + address_delta) + src->stride * (src->y - 1);
+            stride = -src->stride;
+        } else {
+            data = (uint8_t*)(src->data + address_delta);
+            stride = src->stride;
+        }
+
+        if ((src->flags & QXL_BITMAP_UNSTABLE)) {
+            quic_data->data.u.unstable_lines_data.next = data;
+            quic_data->data.u.unstable_lines_data.src_stride = stride;
+            quic_data->data.u.unstable_lines_data.dest_stride = src->stride;
+            quic_data->data.u.unstable_lines_data.lines = src->y;
+            quic_data->data.u.unstable_lines_data.input_bufs_pos = 0;
+            if (!(quic_data->data.u.unstable_lines_data.input_bufs[0] =
+                                            red_display_alloc_compress_buf(display_channel)) ||
+                !(quic_data->data.u.unstable_lines_data.input_bufs[1] =
+                                            red_display_alloc_compress_buf(display_channel))) {
+                return FALSE;
+            }
+            quic_data->data.u.unstable_lines_data.max_lines_bunch =
+                                 sizeof(quic_data->data.u.unstable_lines_data.input_bufs[0]->buf) /
+                                 quic_data->data.u.unstable_lines_data.dest_stride;
+            quic_data->usr.more_lines = quic_usr_more_lines_unstable;
+            size = quic_encode(quic, type, src->x, src->y, NULL, 0, src->stride,
+                               quic_data->data.bufs_head->buf,
+                               sizeof(quic_data->data.bufs_head->buf) >> 2);
+        } else {
+            quic_data->usr.more_lines = quic_usr_no_more_lines;
+            size = quic_encode(quic, type, src->x, src->y, data, src->y, stride,
+                               quic_data->data.bufs_head->buf,
+                               sizeof(quic_data->data.bufs_head->buf) >> 2);
+        }
+    } else {
+        int stride;
+
+        if ((src->flags & QXL_BITMAP_UNSTABLE)) {
+            red_printf_once("unexpected unstable bitmap");
+            return FALSE;
+        }
+        quic_data->data.u.lines_data.address_delta = address_delta;
+        quic_data->data.u.lines_data.stride = src->stride;
+
+        if ((src->flags & QXL_BITMAP_TOP_DOWN)) {
+            quic_data->data.u.lines_data.next = src->data;
+            quic_data->usr.more_lines = quic_usr_more_lines;
+            stride = src->stride;
+        } else {
+            QXLDataChunk *chunk = (QXLDataChunk *)(src->data + address_delta);
+            while (chunk->next_chunk) {
+                chunk = (QXLDataChunk *)(chunk->next_chunk + address_delta);
+                ASSERT(chunk->prev_chunk);
+            }
+            quic_data->data.u.lines_data.next = (ADDRESS)chunk - address_delta;
+            quic_data->usr.more_lines = quic_usr_more_lines_revers;
+            stride = -src->stride;
+        }
+        size = quic_encode(quic, type, src->x, src->y, NULL, 0, stride,
+                           quic_data->data.bufs_head->buf,
+                           sizeof(quic_data->data.bufs_head->buf) >> 2);
+    }
+
+    // the compressed buffer is bigger than the original data
+    if ((size << 2) > (src->y * src->stride)) {
+        longjmp(quic_data->data.jmp_env, 1);
+    }
+
+    dest->descriptor.type = IMAGE_TYPE_QUIC;
+    dest->quic.data_size = size << 2;
+
+    o_comp_data->raw_size = sizeof(QUICImage);
+    o_comp_data->comp_buf = quic_data->data.bufs_head;
+    o_comp_data->comp_buf_size = size << 2;
+    o_comp_data->plt_ptr = NULL;
+    o_comp_data->flags_ptr = NULL;
+
+    stat_compress_add(&display_channel->quic_stat, start_time, src->stride * src->y,
+                      o_comp_data->comp_buf_size);
+    return TRUE;
+}
+
+#define MIN_SIZE_TO_COMPRESS 54
+#define MIN_DIMENSION_TO_QUIC 3
+static inline int red_compress_image(DisplayChannel *display_channel,
+                                     RedImage *dest, Bitmap *src, Drawable *drawable,
+                                     compress_send_data_t* o_comp_data)
+{
+    image_compression_t image_compression = display_channel->base.worker->image_compression;
+    int quic_compress = FALSE;
+
+    if ((image_compression == IMAGE_COMPRESS_OFF) ||
+        ((src->y * src->stride) < MIN_SIZE_TO_COMPRESS)) { // TODO: change the size cond
+        return FALSE;
+    } else if (image_compression == IMAGE_COMPRESS_QUIC) {
+        if (BITMAP_FMT_IS_PLT[src->format]) {
+            return FALSE;
+        } else {
+            quic_compress = TRUE;
+        }
+    } else {
+        /*
+            lz doesn't handle (1) bitmaps with strides that are larger than the width
+            of the image in bytes (2) unstable bitmaps
+        */
+        if (_stride_is_extra(src) || (src->flags & QXL_BITMAP_UNSTABLE)) {
+            if ((image_compression == IMAGE_COMPRESS_LZ) ||
+                (image_compression == IMAGE_COMPRESS_GLZ) ||
+                BITMAP_FMT_IS_PLT[src->format]) {
+                return FALSE;
+            } else {
+                quic_compress = TRUE;
+            }
+        } else {
+            if ((image_compression == IMAGE_COMPRESS_AUTO_LZ) ||
+                (image_compression == IMAGE_COMPRESS_AUTO_GLZ)) {
+                if ((src->x < MIN_DIMENSION_TO_QUIC) || (src->y < MIN_DIMENSION_TO_QUIC)) {
+                    quic_compress = FALSE;
+                } else {
+                    quic_compress = BITMAP_FMT_IS_RGB[src->format] &&
+                        _bitmap_is_gradual(display_channel->base.worker, src);
+                }
+            } else {
+                quic_compress = FALSE;
+            }
+        }
+    }
+
+    if (quic_compress) {
+#ifdef COMPRESS_DEBUG
+        red_printf("QUIC compress");
+#endif
+        return red_quic_compress_image(display_channel, dest, src, o_comp_data);
+    } else {
+        int glz;
+        int ret;
+        if ((image_compression == IMAGE_COMPRESS_AUTO_GLZ) ||
+            (image_compression == IMAGE_COMPRESS_GLZ)) {
+            glz = BITMAP_FMT_IS_RGB[src->format] && (
+                    (src->x * src->y) < glz_enc_dictionary_get_size(
+                        display_channel->glz_dict->dict));
+        } else if ((image_compression == IMAGE_COMPRESS_AUTO_LZ) ||
+                   (image_compression == IMAGE_COMPRESS_LZ)) {
+            glz = FALSE;
+        } else {
+            red_error("invalid image compression type %u", image_compression);
+        }
+
+        if (glz) {
+            /* using the global dictionary only if it is not freezed */
+            pthread_rwlock_rdlock(&display_channel->glz_dict->encode_lock);
+            if (!display_channel->glz_dict->migrate_freeze) {
+                ret = red_glz_compress_image(
+                        display_channel, dest, src, drawable, o_comp_data);
+            } else {
+                glz = FALSE;
+            }
+            pthread_rwlock_unlock(&display_channel->glz_dict->encode_lock);
+        }
+
+        if (!glz) {
+            ret = red_lz_compress_image(display_channel, dest, src, o_comp_data);
+#ifdef COMPRESS_DEBUG
+            red_printf("LZ LOCAL compress");
+#endif
+        }
+#ifdef COMPRESS_DEBUG
+        else {
+            red_printf("LZ global compress fmt=%d", src->format);
+        }
+#endif
+        return ret;
+    }
+}
+
+static inline void red_display_add_image_to_pixmap_cache(DisplayChannel *display_channel,
+                                                         QXLImage *qxl_image, RedImage *io_image)
+{
+    if ((qxl_image->descriptor.flags & QXL_IMAGE_CACHE)) {
+        ASSERT(qxl_image->descriptor.width * qxl_image->descriptor.height > 0);
+        if (pixmap_cache_add(display_channel->pixmap_cache, qxl_image->descriptor.id,
+                             qxl_image->descriptor.width * qxl_image->descriptor.height,
+                             display_channel)) {
+            io_image->descriptor.flags |= IMAGE_CACHE_ME;
+            stat_inc_counter(display_channel->add_to_cache_counter, 1);
+        }
+    }
+
+    if (!(io_image->descriptor.flags & IMAGE_CACHE_ME)) {
+        stat_inc_counter(display_channel->non_cache_counter, 1);
+    }
+}
+
+/* if the number of times fill_bits can be called per one qxl_drawable increases -
+   MAX_LZ_DRAWABLE_INSTANCES must be increased as well */
+static void fill_bits(DisplayChannel *display_channel, PHYSICAL *in_bitmap, Drawable *drawable)
+{
+    RedChannel *channel = &display_channel->base;
+    RedImage *image;
+    QXLImage *qxl_image;
+    uint8_t *data;
+    compress_send_data_t comp_send_data;
+
+    ASSERT(*in_bitmap);
+
+    image = alloc_image(display_channel);
+    qxl_image = (QXLImage *)(*in_bitmap + channel->worker->dev_info.phys_delta);
+
+    image->descriptor.id = qxl_image->descriptor.id;
+    image->descriptor.type = qxl_image->descriptor.type;
+    image->descriptor.flags = 0;
+    image->descriptor.width = qxl_image->descriptor.width;
+    image->descriptor.height = qxl_image->descriptor.height;
+
+    *in_bitmap = channel->send_data.header.size;
+    if ((qxl_image->descriptor.flags & QXL_IMAGE_CACHE)) {
+        if (pixmap_cache_hit(display_channel->pixmap_cache, image->descriptor.id,
+                             display_channel)) {
+            image->descriptor.type = IMAGE_TYPE_FROM_CACHE;
+            add_buf(channel, BUF_TYPE_RAW, image, sizeof(ImageDescriptor));
+            stat_inc_counter(display_channel->cache_hits_counter, 1);
+            return;
+        }
+    }
+
+    switch (qxl_image->descriptor.type) {
+    case IMAGE_TYPE_BITMAP:
+#ifdef DUMP_BITMAP
+        dump_bitmap(display_channel->base.worker, &qxl_image->bitmap);
+#endif
+        /* Images must be added to the cache only after they are compressed
+           in order to prevent starvation in the client between pixmap_cache and
+           global dictionary (in cases of multiple monitors) */
+        if (!red_compress_image(display_channel, image, &qxl_image->bitmap,
+                                drawable, &comp_send_data)) {
+            red_display_add_image_to_pixmap_cache(display_channel, qxl_image, image);
+
+            image->bitmap = qxl_image->bitmap;
+            image->bitmap.flags = image->bitmap.flags & BITMAP_TOP_DOWN;
+            add_buf(channel, BUF_TYPE_RAW, image, sizeof(BitmapImage));
+            fill_palette(display_channel, &(image->bitmap.palette), &(image->bitmap.flags));
+            data = (uint8_t *)(image->bitmap.data + channel->worker->dev_info.phys_delta);
+            image->bitmap.data = channel->send_data.header.size;
+            add_buf(channel,
+                    (qxl_image->bitmap.flags & QXL_BITMAP_DIRECT) ? BUF_TYPE_RAW : BUF_TYPE_CHUNK,
+                    data, image->bitmap.y * image->bitmap.stride);
+        } else {
+            red_display_add_image_to_pixmap_cache(display_channel, qxl_image, image);
+
+            add_buf((RedChannel *)display_channel, BUF_TYPE_RAW, image, comp_send_data.raw_size);
+            add_buf((RedChannel *)display_channel, BUF_TYPE_COMPRESS_BUF,
+                    comp_send_data.comp_buf, comp_send_data.comp_buf_size);
+
+            if (comp_send_data.plt_ptr != NULL) {
+                fill_palette(display_channel, comp_send_data.plt_ptr, comp_send_data.flags_ptr);
+            }
+        }
+        break;
+    case IMAGE_TYPE_QUIC:
+        red_display_add_image_to_pixmap_cache(display_channel, qxl_image, image);
+        image->quic = qxl_image->quic;
+        add_buf(channel, BUF_TYPE_RAW, image, sizeof(QUICImage));
+        add_buf(channel, BUF_TYPE_CHUNK, qxl_image->quic.data, qxl_image->quic.data_size);
+        break;
+    default:
+        red_error("invalid image type %u", image->descriptor.type);
+    }
+}
+
+static void fill_brush(DisplayChannel *display_channel, Brush *brush, Drawable *drawable)
+{
+    if (brush->type == BRUSH_TYPE_PATTERN) {
+        fill_bits(display_channel, &brush->u.pattern.pat, drawable);
+    }
+}
+
+static void fill_mask(DisplayChannel *display_channel, QMask *mask, Drawable *drawable)
+{
+    if (mask->bitmap) {
+        if (display_channel->base.worker->image_compression != IMAGE_COMPRESS_OFF) {
+            image_compression_t save_img_comp = display_channel->base.worker->image_compression;
+            display_channel->base.worker->image_compression = IMAGE_COMPRESS_OFF;
+            fill_bits(display_channel, &mask->bitmap, drawable);
+            display_channel->base.worker->image_compression = save_img_comp;
+        } else {
+            fill_bits(display_channel, &mask->bitmap, drawable);
+        }
+    }
+}
+
+static void fill_attr(DisplayChannel *display_channel, LineAttr *attr)
+{
+    if (attr->style_nseg) {
+        RedChannel *channel = &display_channel->base;
+        uint8_t *buf = (uint8_t *)(attr->style + channel->worker->dev_info.phys_delta);
+        ASSERT(attr->style);
+        attr->style = channel->send_data.header.size;
+        add_buf(channel, BUF_TYPE_RAW, buf, attr->style_nseg * sizeof(uint32_t));
+    }
+}
+
+static void fill_cursor(CursorChannel *cursor_channel, RedCursor *red_cursor, CursorItem *cursor)
+{
+    RedChannel *channel = &cursor_channel->base;
+
+    if (!cursor) {
+        red_cursor->flags = RED_CURSOR_NONE;
+        return;
+    }
+
+    if (cursor->type == CURSOR_TYPE_DEV) {
+        QXLCursorCmd *cursor_cmd;
+        QXLCursor *qxl_cursor;
+
+        cursor_cmd = CONTAINEROF(cursor, QXLCursorCmd, device_data);
+        qxl_cursor = (QXLCursor *)(cursor_cmd->u.set.shape + channel->worker->dev_info.phys_delta);
+        red_cursor->flags = 0;
+        red_cursor->header = qxl_cursor->header;
+
+        if (red_cursor->header.unique) {
+            if (red_cursor_cache_find(cursor_channel, red_cursor->header.unique)) {
+                red_cursor->flags |= RED_CURSOR_FROM_CACHE;
+                return;
+            }
+            if (red_cursor_cache_add(cursor_channel, red_cursor->header.unique, 1)) {
+                red_cursor->flags |= RED_CURSOR_CACHE_ME;
+            }
+        }
+
+        if (qxl_cursor->data_size) {
+            add_buf(channel, BUF_TYPE_CHUNK, &qxl_cursor->chunk, qxl_cursor->data_size);
+        }
+    } else {
+        LocalCursor *local_cursor;
+        ASSERT(cursor->type == CURSOR_TYPE_LOCAL);
+        local_cursor = (LocalCursor *)cursor;
+        *red_cursor = local_cursor->red_cursor;
+        add_buf(channel, BUF_TYPE_RAW, local_cursor->red_cursor.data, local_cursor->data_size);
+    }
+}
+
+static inline void red_channel_reset_send_data(RedChannel *channel)
+{
+    channel->send_data.pos = 0;
+    channel->send_data.n_bufs = 1;
+    channel->send_data.header.size = 0;
+    channel->send_data.header.sub_list = 0;
+    ++channel->send_data.header.serial;
+    channel->send_data.bufs[0].type = BUF_TYPE_RAW;
+    channel->send_data.bufs[0].size = sizeof(RedDataHeader);
+    channel->send_data.bufs[0].data = (void *)&channel->send_data.header;
+}
+
+static inline void red_display_reset_send_data(DisplayChannel *channel)
+{
+    red_channel_reset_send_data((RedChannel *)channel);
+    channel->send_data.bitmap_pos = 0;
+    red_display_reset_compress_buf(channel);
+    channel->send_data.free_list.res->count = 0;
+    memset(channel->send_data.free_list.sync, 0, sizeof(channel->send_data.free_list.sync));
+}
+
+static inline void red_send_qxl_drawable(RedWorker *worker, DisplayChannel *display_channel,
+                                         Drawable *item)
+{
+    QXLDrawable *drawable = item->qxl_drawable;
+
+    RedChannel *channel = &display_channel->base;
+    switch (drawable->type) {
+    case QXL_DRAW_FILL:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_FILL;
+        fill_base(display_channel, &display_channel->send_data.u.fill.base, drawable,
+                  sizeof(RedFill));
+        display_channel->send_data.u.fill.data = drawable->u.fill;
+        fill_brush(display_channel, &display_channel->send_data.u.fill.data.brush, item);
+        fill_mask(display_channel, &display_channel->send_data.u.fill.data.mask, item);
+        break;
+    case QXL_DRAW_OPAQUE:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_OPAQUE;
+        fill_base(display_channel, &display_channel->send_data.u.opaque.base, drawable,
+                  sizeof(RedOpaque));
+        display_channel->send_data.u.opaque.data = drawable->u.opaque;
+        fill_bits(display_channel, &display_channel->send_data.u.opaque.data.src_bitmap, item);
+        fill_brush(display_channel, &display_channel->send_data.u.opaque.data.brush, item);
+        fill_mask(display_channel, &display_channel->send_data.u.opaque.data.mask, item);
+        break;
+    case QXL_DRAW_COPY:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
+        fill_base(display_channel, &display_channel->send_data.u.copy.base, drawable,
+                  sizeof(RedCopy));
+        display_channel->send_data.u.copy.data = drawable->u.copy;
+        fill_bits(display_channel, &display_channel->send_data.u.copy.data.src_bitmap, item);
+        fill_mask(display_channel, &display_channel->send_data.u.copy.data.mask, item);
+        break;
+    case QXL_DRAW_TRANSPARENT:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_TRANSPARENT;
+        fill_base(display_channel, &display_channel->send_data.u.transparent.base, drawable,
+                  sizeof(RedTransparent));
+        display_channel->send_data.u.transparent.data = drawable->u.transparent;
+        fill_bits(display_channel, &display_channel->send_data.u.transparent.data.src_bitmap, item);
+        break;
+    case QXL_DRAW_ALPHA_BLEND:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_ALPHA_BLEND;
+        fill_base(display_channel, &display_channel->send_data.u.alpha_blend.base, drawable,
+                  sizeof(RedAlphaBlend));
+        display_channel->send_data.u.alpha_blend.data = drawable->u.alpha_blend;
+        fill_bits(display_channel, &display_channel->send_data.u.alpha_blend.data.src_bitmap, item);
+        break;
+    case QXL_COPY_BITS:
+        channel->send_data.header.type = RED_DISPLAY_COPY_BITS;
+        fill_base(display_channel, &display_channel->send_data.u.copy_bits.base, drawable,
+                  sizeof(RedCopyBits));
+        display_channel->send_data.u.copy_bits.src_pos = drawable->u.copy_bits.src_pos;
+        break;
+    case QXL_DRAW_BLEND:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_BLEND;
+        fill_base(display_channel, &display_channel->send_data.u.blend.base, drawable,
+                  sizeof(RedBlend));
+        display_channel->send_data.u.blend.data = drawable->u.blend;
+        fill_bits(display_channel, &display_channel->send_data.u.blend.data.src_bitmap, item);
+        fill_mask(display_channel, &display_channel->send_data.u.blend.data.mask, item);
+        break;
+    case QXL_DRAW_BLACKNESS:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_BLACKNESS;
+        fill_base(display_channel, &display_channel->send_data.u.blackness.base, drawable,
+                  sizeof(RedBlackness));
+        display_channel->send_data.u.blackness.data = drawable->u.blackness;
+        fill_mask(display_channel, &display_channel->send_data.u.blackness.data.mask, item);
+        break;
+    case QXL_DRAW_WHITENESS:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_WHITENESS;
+        fill_base(display_channel, &display_channel->send_data.u.whiteness.base, drawable,
+                  sizeof(RedWhiteness));
+        display_channel->send_data.u.whiteness.data = drawable->u.whiteness;
+        fill_mask(display_channel, &display_channel->send_data.u.whiteness.data.mask, item);
+        break;
+    case QXL_DRAW_INVERS:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_INVERS;
+        fill_base(display_channel, &display_channel->send_data.u.invers.base, drawable,
+                  sizeof(RedInvers));
+        display_channel->send_data.u.invers.data = drawable->u.invers;
+        fill_mask(display_channel, &display_channel->send_data.u.invers.data.mask, item);
+        break;
+    case QXL_DRAW_ROP3:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_ROP3;
+        fill_base(display_channel, &display_channel->send_data.u.rop3.base, drawable,
+                  sizeof(RedRop3));
+        display_channel->send_data.u.rop3.data = drawable->u.rop3;
+        fill_bits(display_channel, &display_channel->send_data.u.rop3.data.src_bitmap, item);
+        fill_brush(display_channel, &display_channel->send_data.u.rop3.data.brush, item);
+        fill_mask(display_channel, &display_channel->send_data.u.rop3.data.mask, item);
+        break;
+    case QXL_DRAW_STROKE:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_STROKE;
+        fill_base(display_channel, &display_channel->send_data.u.stroke.base, drawable,
+                  sizeof(RedStroke));
+        display_channel->send_data.u.stroke.data = drawable->u.stroke;
+        fill_path(display_channel, &display_channel->send_data.u.stroke.data.path);
+        fill_attr(display_channel, &display_channel->send_data.u.stroke.data.attr);
+        fill_brush(display_channel, &display_channel->send_data.u.stroke.data.brush, item);
+        break;
+    case QXL_DRAW_TEXT:
+        channel->send_data.header.type = RED_DISPLAY_DRAW_TEXT;
+        fill_base(display_channel, &display_channel->send_data.u.text.base, drawable,
+                  sizeof(RedText));
+        display_channel->send_data.u.text.data = drawable->u.text;
+        fill_brush(display_channel, &display_channel->send_data.u.text.data.fore_brush, item);
+        fill_brush(display_channel, &display_channel->send_data.u.text.data.back_brush, item);
+        fill_str(display_channel, &display_channel->send_data.u.text.data.str);
+        break;
+    default:
+        red_error("invalid type");
+    }
+    display_begin_send_massage(display_channel, &item->pipe_item);
+}
+
+#define MAX_SEND_VEC 100
+
+static inline BufDescriptor *find_buf(RedChannel *channel, int buf_pos, int *buf_offset)
+{
+    BufDescriptor *buf;
+    int pos = 0;
+
+    for (buf = channel->send_data.bufs; buf_pos >= pos + buf->size; buf++) {
+        pos += buf->size;
+        ASSERT(buf != &channel->send_data.bufs[channel->send_data.n_bufs - 1]);
+    }
+    *buf_offset = buf_pos - pos;
+    return buf;
+}
+
+static inline uint32_t __fill_iovec(BufDescriptor *buf, int skip, struct iovec *vec, int *vec_index,
+                                    long phys_delta)
+{
+    uint32_t size = 0;
+
+    switch (buf->type) {
+    case BUF_TYPE_RAW:
+        vec[*vec_index].iov_base = buf->data + skip;
+        vec[*vec_index].iov_len = size = buf->size - skip;
+        (*vec_index)++;
+        break;
+    case BUF_TYPE_COMPRESS_BUF: {
+        RedCompressBuf *comp_buf = (RedCompressBuf *)buf->data;
+        int max = buf->size - skip;
+        int now;
+        do {
+            ASSERT(comp_buf);
+            if (skip >= sizeof(comp_buf->buf)) {
+                skip -= sizeof(comp_buf->buf);
+                comp_buf = comp_buf->send_next;
+                continue;
+            }
+            now = MIN(sizeof(comp_buf->buf) - skip, max);
+            max -= now;
+            size += now;
+            vec[*vec_index].iov_base = (uint8_t*)comp_buf->buf + skip;
+            vec[*vec_index].iov_len = now;
+            skip = 0;
+            comp_buf = comp_buf->send_next;
+            (*vec_index)++;
+        } while (max && *vec_index < MAX_SEND_VEC);
+        break;
+    }
+    case BUF_TYPE_CHUNK: {
+        QXLDataChunk *chunk = (QXLDataChunk *)buf->data;
+        do {
+            int data_size = chunk->data_size;
+            int skip_now = MIN(data_size, skip);
+            skip -= skip_now;
+            data_size -= skip_now;
+
+            if (data_size) {
+                size += data_size;
+                vec[*vec_index].iov_base = chunk->data + skip_now;
+                vec[*vec_index].iov_len = data_size;
+                (*vec_index)++;
+            }
+            chunk = chunk->next_chunk ? (QXLDataChunk *)(chunk->next_chunk + phys_delta) : NULL;
+        } while (chunk && *vec_index < MAX_SEND_VEC);
+        break;
+    }
+    default:
+        red_error("invalid type");
+    }
+    return size;
+}
+
+static inline void fill_iovec(RedChannel *channel, struct iovec *vec, int *vec_size)
+{
+    int vec_index = 0;
+    uint32_t pos = channel->send_data.pos;
+
+    ASSERT(channel->send_data.size != pos && channel->send_data.size > pos);
+
+    do {
+        BufDescriptor *buf;
+        int buf_offset;
+
+        buf = find_buf(channel, pos, &buf_offset);
+        ASSERT(buf);
+        pos += __fill_iovec(buf, buf_offset, vec, &vec_index, channel->worker->dev_info.phys_delta);
+    } while (vec_index < MAX_SEND_VEC && pos != channel->send_data.size);
+    *vec_size = vec_index;
+}
+
+static void inline channel_release_res(RedChannel *channel)
+{
+    if (!channel->send_data.item) {
+        return;
+    }
+    channel->release_item(channel, channel->send_data.item);
+    channel->send_data.item = NULL;
+}
+
+static void red_send_data(RedChannel *channel, void *item)
+{
+    for (;;) {
+        uint32_t n = channel->send_data.size - channel->send_data.pos;
+        struct iovec vec[MAX_SEND_VEC];
+        int vec_size;
+
+        if (!n) {
+            channel->send_data.blocked = FALSE;
+            if (channel->send_data.item) {
+                channel->release_item(channel, channel->send_data.item);
+                channel->send_data.item = NULL;
+            }
+            break;
+        }
+        fill_iovec(channel, vec, &vec_size);
+        ASSERT(channel->peer);
+        if ((n = channel->peer->cb_writev(channel->peer->ctx, vec, vec_size)) == -1) {
+            switch (errno) {
+            case EAGAIN:
+                channel->send_data.blocked = TRUE;
+                if (item) {
+                    channel->hold_item(item);
+                    channel->send_data.item = item;
+                }
+                return;
+            case EINTR:
+                break;
+            case EPIPE:
+                channel->disconnect(channel);
+                return;
+            default:
+                red_printf("%s", strerror(errno));
+                channel->disconnect(channel);
+                return;
+            }
+        } else {
+            channel->send_data.pos += n;
+            stat_inc_counter(channel->out_bytes_counter, n);
+        }
+    }
+}
+
+static void display_channel_push_release(DisplayChannel *channel, uint8_t type, uint64_t id,
+                                         uint64_t* sync_data)
+{
+    FreeList *free_list = &channel->send_data.free_list;
+    int i;
+
+    for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
+        free_list->sync[i] = MAX(free_list->sync[i], sync_data[i]);
+    }
+
+    if (free_list->res->count == free_list->res_size) {
+        RedResorceList *new_list;
+        new_list = malloc(sizeof(*new_list) + free_list->res_size * sizeof(RedResorceID) * 2);
+        if (!new_list) {
+            PANIC("malloc failed");
+        }
+        new_list->count = free_list->res->count;
+        memcpy(new_list->resorces, free_list->res->resorces,
+               new_list->count * sizeof(RedResorceID));
+        free(free_list->res);
+        free_list->res = new_list;
+        free_list->res_size *= 2;
+    }
+    free_list->res->resorces[free_list->res->count].type = type;
+    free_list->res->resorces[free_list->res->count++].id = id;
+}
+
+static inline void red_begin_send_massage(RedChannel *channel, void *item)
+{
+    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->messages_window++;
+    red_send_data(channel, item);
+}
+
+static inline void display_begin_send_massage(DisplayChannel *channel, void *item)
+{
+    FreeList *free_list = &channel->send_data.free_list;
+
+    if (free_list->res->count) {
+        int sync_count = 0;
+        int sub_index;
+        int i;
+
+        channel->base.send_data.header.sub_list = channel->base.send_data.header.size;
+        for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
+            if (i != channel->base.id && free_list->sync[i] != 0) {
+                free_list->wait.header.wait_list[sync_count].channel_type = RED_CHANNEL_DISPLAY;
+                free_list->wait.header.wait_list[sync_count].channel_id = i;
+                free_list->wait.header.wait_list[sync_count++].message_serial = free_list->sync[i];
+            }
+        }
+        RedSubMessageList *sub_list = &channel->send_data.sub_list.sub_list;
+        RedSubMessage *sub_header = channel->send_data.sub_header;
+        if (sync_count) {
+            sub_list->size = 2;
+            add_buf((RedChannel*)channel, BUF_TYPE_RAW, sub_list,
+                    sizeof(*sub_list) + 2 * sizeof(sub_list->sub_messages[0]));
+            sub_list->sub_messages[0] = channel->base.send_data.header.size;
+            sub_header[0].type = RED_WAIT_FOR_CHANNELS;
+            sub_header[0].size = sizeof(free_list->wait.header) +
+                                 sync_count * sizeof(free_list->wait.buf[0]);
+            add_buf((RedChannel*)channel, BUF_TYPE_RAW, sub_header, sizeof(*sub_header));
+            free_list->wait.header.wait_count = sync_count;
+            add_buf((RedChannel*)channel, BUF_TYPE_RAW, &free_list->wait.header,
+                    sub_header[0].size);
+            sub_list->sub_messages[1] = channel->base.send_data.header.size;
+            sub_index = 1;
+        } else {
+            sub_list->size = 1;
+            add_buf((RedChannel*)channel, BUF_TYPE_RAW, sub_list,
+                    sizeof(*sub_list) + sizeof(sub_list->sub_messages[0]));
+            sub_list->sub_messages[0] = channel->base.send_data.header.size;
+            sub_index = 0;
+        }
+        sub_header[sub_index].type = RED_DISPLAY_INVAL_LIST;
+        sub_header[sub_index].size = sizeof(*free_list->res) + free_list->res->count *
+                                     sizeof(free_list->res->resorces[0]);
+        add_buf((RedChannel*)channel, BUF_TYPE_RAW, &sub_header[sub_index], sizeof(*sub_header));
+        add_buf((RedChannel*)channel, BUF_TYPE_RAW, free_list->res, sub_header[sub_index].size);
+    }
+    red_begin_send_massage((RedChannel *)channel, item);
+}
+
+static inline RedChannel *red_ref_channel(RedChannel *channel)
+{
+    if (!channel) {
+        return NULL;
+    }
+    ++channel->listener.refs;
+    return channel;
+}
+
+static inline void red_unref_channel(RedChannel *channel)
+{
+    ASSERT(channel);
+    if (!--channel->listener.refs) {
+        free(channel);
+    }
+}
+
+static inline uint8_t *red_get_image_line(QXLDataChunk **chunk, int *offset, int stride,
+                                          long phys_delta)
+{
+    uint8_t *ret;
+    if ((*chunk)->data_size == *offset) {
+        if ((*chunk)->next_chunk == 0) {
+            return NULL;
+        }
+        *offset = 0;
+        *chunk = (QXLDataChunk *)((*chunk)->next_chunk + phys_delta);
+    }
+
+    if ((*chunk)->data_size - *offset < stride) {
+        red_printf("bad chunk aligment");
+        return NULL;
+    }
+    ret = (*chunk)->data + *offset;
+    *offset += stride;
+    return ret;
+}
+
+static void red_display_share_stream_buf(DisplayChannel *display_channel)
+{
+}
+
+static void red_display_unshare_stream_buf(DisplayChannel *display_channel)
+{
+}
+
+#define YUV32
+#include "red_yuv.h"
+#undef YUV32
+
+#define YUV24
+#include "red_yuv.h"
+#undef YUV24
+
+#define YUV16
+#include "red_yuv.h"
+#undef YUV16
+
+static inline int red_send_stream_data(DisplayChannel *display_channel, Drawable *drawable)
+{
+    Stream *stream = drawable->stream;
+    QXLImage *qxl_image;
+    RedChannel *channel;
+    RedWorker* worker;
+    int n;
+
+    ASSERT(stream);
+    ASSERT(drawable->qxl_drawable->type == QXL_DRAW_COPY);
+
+    channel = &display_channel->base;
+    worker = channel->worker;
+    qxl_image = (QXLImage *)(drawable->qxl_drawable->u.copy.src_bitmap +
+                             worker->dev_info.phys_delta);
+
+    if (qxl_image->descriptor.type != IMAGE_TYPE_BITMAP ||
+                                            (qxl_image->bitmap.flags & QXL_BITMAP_DIRECT)) {
+        return FALSE;
+    }
+
+    StreamAgent *agent = &display_channel->stream_agents[stream - worker->streams_buf];
+    uint64_t time_now = red_now();
+    if (time_now - agent->lats_send_time < (1000 * 1000 * 1000) / agent->fps) {
+        agent->frames--;
+        return TRUE;
+    }
+
+    switch (qxl_image->bitmap.format) {
+    case BITMAP_FMT_32BIT:
+        if (!red_rgb_to_yuv420_32bpp(&drawable->qxl_drawable->u.copy.src_area,
+                                     &qxl_image->bitmap, stream->av_frame,
+                                     worker->dev_info.phys_delta,
+                                     stream - worker->streams_buf, stream)) {
+            return FALSE;
+        }
+        break;
+    case BITMAP_FMT_16BIT:
+        if (!red_rgb_to_yuv420_16bpp(&drawable->qxl_drawable->u.copy.src_area,
+                                     &qxl_image->bitmap, stream->av_frame,
+                                     worker->dev_info.phys_delta,
+                                     stream - worker->streams_buf, stream)) {
+            return FALSE;
+        }
+        break;
+    case BITMAP_FMT_24BIT:
+        if (!red_rgb_to_yuv420_24bpp(&drawable->qxl_drawable->u.copy.src_area,
+                                     &qxl_image->bitmap, stream->av_frame,
+                                     worker->dev_info.phys_delta,
+                                     stream - worker->streams_buf, stream)) {
+            return FALSE;
+        }
+        break;
+    default:
+        red_printf_some(1000, "unsupported format %d", qxl_image->bitmap.format);
+        return FALSE;
+    }
+#if 1
+    uint32_t min_buf_size = stream->av_ctx->width * stream->av_ctx->height * sizeof(uint32_t) / 2;
+    min_buf_size += FF_MIN_BUFFER_SIZE;
+    if (display_channel->send_data.stream_outbuf_size < min_buf_size) {
+        uint8_t *new_buf;
+
+        if (!(new_buf = malloc(min_buf_size + FF_INPUT_BUFFER_PADDING_SIZE))) {
+            return FALSE;
+        }
+
+        red_display_unshare_stream_buf(display_channel);
+        free(display_channel->send_data.stream_outbuf);
+        display_channel->send_data.stream_outbuf = new_buf;
+        display_channel->send_data.stream_outbuf_size = min_buf_size;
+        red_display_share_stream_buf(display_channel);
+    }
+    n = avcodec_encode_video(stream->av_ctx, display_channel->send_data.stream_outbuf,
+                             display_channel->send_data.stream_outbuf_size,
+                             stream->av_frame);
+
+    if (n <= 0) {
+        red_printf("avcodec_encode_video failed");
+        return FALSE;
+    }
+
+    if (n > display_channel->send_data.stream_outbuf_size) {
+        PANIC("buf error");
+    }
+#else
+    for (;;) {
+        n = avcodec_encode_video(stream->av_ctx, display_channel->send_data.stream_outbuf,
+                                 display_channel->send_data.stream_outbuf_size,
+                                 stream->av_frame);
+        if (n < 0) {
+            uint8_t *new_buf;
+            size_t max_size;
+            size_t new_size;
+
+            max_size = stream->av_ctx->width * stream->av_ctx->height * sizeof(uint32_t);
+            max_size += MAX(1024, max_size / 10);
+
+            if (display_channel->send_data.stream_outbuf_size == max_size) {
+                return FALSE;
+            }
+
+            new_size = display_channel->send_data.stream_outbuf_size * 2;
+            new_size = MIN(new_size, max_size);
+
+            if (!(new_buf = malloc(new_size + FF_INPUT_BUFFER_PADDING_SIZE))) {
+                return FALSE;
+            }
+            red_printf("new streaming video buf size %u", new_size);
+            red_display_unshare_stream_buf(display_channel);
+            free(display_channel->send_data.stream_outbuf);
+            display_channel->send_data.stream_outbuf = new_buf;
+            display_channel->send_data.stream_outbuf_size = new_size;
+            red_display_share_stream_buf(display_channel);
+            continue;
+        }
+        ASSERT(n <= display_channel->send_data.stream_outbuf_size);
+        break;
+    }
+ #endif
+    channel->send_data.header.type = RED_DISPLAY_STREAM_DATA;
+    RedStreamData* stream_data = &display_channel->send_data.u.stream_data;
+    add_buf(channel, BUF_TYPE_RAW, stream_data, sizeof(RedStreamData));
+    add_buf(channel, BUF_TYPE_RAW, display_channel->send_data.stream_outbuf,
+            n + FF_INPUT_BUFFER_PADDING_SIZE);
+
+    stream_data->id = stream - worker->streams_buf;
+    stream_data->multi_media_time = drawable->qxl_drawable->mm_time;
+    stream_data->data_size = n;
+    stream_data->ped_size = FF_INPUT_BUFFER_PADDING_SIZE;
+    display_begin_send_massage(display_channel, NULL);
+    agent->lats_send_time = time_now;
+    return TRUE;
+}
+
+static inline void send_qxl_drawable(DisplayChannel *display_channel, Drawable *item)
+{
+    RedChannel *channel;
+
+    ASSERT(display_channel);
+    channel = &display_channel->base;
+
+    if (item->stream && red_send_stream_data(display_channel, item)) {
+        return;
+    }
+    red_send_qxl_drawable(display_channel->base.worker, display_channel, item);
+}
+
+static void red_send_mode(DisplayChannel *display_channel)
+{
+    RedChannel *channel;
+    RedWorker *worker;
+
+    ASSERT(display_channel);
+    worker = display_channel->base.worker;
+    channel = &display_channel->base;
+    channel->send_data.header.type = RED_DISPLAY_MODE;
+    display_channel->send_data.u.mode.x_res = worker->dev_info.x_res;
+    display_channel->send_data.u.mode.y_res = worker->dev_info.y_res;
+    display_channel->send_data.u.mode.bits = worker->dev_info.bits;
+
+    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.mode, sizeof(RedMode));
+
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void red_send_set_ack(RedChannel *channel)
+{
+    ASSERT(channel);
+    channel->send_data.header.type = RED_SET_ACK;
+    channel->send_data.u.ack.generation = ++channel->ack_generation;
+    channel->send_data.u.ack.window = channel->client_ack_window;
+    channel->messages_window = 0;
+
+    add_buf(channel, BUF_TYPE_RAW, &channel->send_data.u.ack, sizeof(RedSetAck));
+    red_begin_send_massage(channel, NULL);
+}
+
+static inline void red_send_verb(RedChannel *channel, uint16_t verb)
+{
+    ASSERT(channel);
+    channel->send_data.header.type = verb;
+    red_begin_send_massage(channel, NULL);
+}
+
+static inline void display_send_verb(DisplayChannel *channel, uint16_t verb)
+{
+    ASSERT(channel);
+    channel->base.send_data.header.type = verb;
+    display_begin_send_massage(channel, NULL);
+}
+
+static inline void __red_send_inval(RedChannel *channel, CacheItem *cach_item,
+                                    RedInvalOne *inval_one)
+{
+    channel->send_data.header.type = cach_item->inval_type;
+    inval_one->id = *(uint64_t *)&cach_item->id;
+    add_buf(channel, BUF_TYPE_RAW, inval_one, sizeof(*inval_one));
+}
+
+static void red_send_inval(RedChannel *channel, CacheItem *cach_item, RedInvalOne *inval_one)
+{
+    __red_send_inval(channel, cach_item, inval_one);
+    red_begin_send_massage(channel, NULL);
+}
+
+static void red_display_send_inval(DisplayChannel *display_channel, CacheItem *cach_item)
+{
+    __red_send_inval((RedChannel *)display_channel, cach_item,
+                     &display_channel->send_data.u.inval_one);
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void display_channel_send_migrate(DisplayChannel *display_channel)
+{
+    display_channel->base.send_data.header.type = RED_MIGRATE;
+    display_channel->send_data.u.migrate.flags = RED_MIGRATE_NEED_FLUSH |
+                                                 RED_MIGRATE_NEED_DATA_TRANSFER;
+    add_buf((RedChannel*)display_channel, BUF_TYPE_RAW, &display_channel->send_data.u.migrate,
+            sizeof(display_channel->send_data.u.migrate));
+    display_channel->expect_migrate_mark = TRUE;
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void display_channel_send_migrate_data(DisplayChannel *display_channel)
+{
+    DisplayChannelMigrateData* display_data;
+
+    display_channel->base.send_data.header.type = RED_MIGRATE_DATA;
+    ASSERT(display_channel->pixmap_cache);
+    display_data = &display_channel->send_data.u.migrate_data;
+    display_data->magic = DISPLAY_MIGRATE_DATA_MAGIC;
+    ASSERT(MAX_CACHE_CLIENTS == 4); //MIGRATE_DATA_VERSION dependent
+    display_data->version = DISPLAY_MIGRATE_DATA_VERSION;
+
+    display_data->message_serial = channel_message_serial((RedChannel *)display_channel);
+
+    display_data->pixmap_cache_freezer = pixmap_cache_freeze(display_channel->pixmap_cache);
+    display_data->pixmap_cache_id = display_channel->pixmap_cache->id;
+    display_data->pixmap_cache_size = display_channel->pixmap_cache->size;
+    memcpy(display_data->pixmap_cache_clients, display_channel->pixmap_cache->sync,
+           sizeof(display_data->pixmap_cache_clients));
+
+    ASSERT(display_channel->glz_dict);
+    red_freeze_glz(display_channel);
+    display_data->glz_dict_id = display_channel->glz_dict->id;
+    glz_enc_dictionary_get_restore_data(display_channel->glz_dict->dict,
+                                        &display_data->glz_dict_restore_data,
+                                        &display_channel->glz_data.usr);
+
+    add_buf((RedChannel *)display_channel, BUF_TYPE_RAW, &display_channel->send_data.u.migrate_data,
+            sizeof(display_channel->send_data.u.migrate_data));
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void display_channel_pixmap_sync(DisplayChannel *display_channel)
+{
+    RedWaitForChannels *wait;
+    PixmapCache *pixmap_cache;
+
+
+    display_channel->base.send_data.header.type = RED_WAIT_FOR_CHANNELS;
+    wait = &display_channel->send_data.u.wait.header;
+    pixmap_cache = display_channel->pixmap_cache;
+
+
+    pthread_mutex_lock(&pixmap_cache->lock);
+
+    wait->wait_count = 1;
+    wait->wait_list[0].channel_type = RED_CHANNEL_DISPLAY;
+    wait->wait_list[0].channel_id = pixmap_cache->generation_initiator.client;
+    wait->wait_list[0].message_serial = pixmap_cache->generation_initiator.message;
+    display_channel->pixmap_cache_generation = pixmap_cache->generation;
+    display_channel->pending_pixmaps_sync = FALSE;
+
+    pthread_mutex_unlock(&pixmap_cache->lock);
+
+    add_buf((RedChannel *)display_channel, BUF_TYPE_RAW, wait,
+            sizeof(*wait) + sizeof(wait->wait_list[0]));
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void display_channel_reset_cache(DisplayChannel *display_channel)
+{
+    RedWaitForChannels *wait = &display_channel->send_data.u.wait.header;
+
+    display_channel->base.send_data.header.type = RED_DISPLAY_INVAL_ALL_PIXMAPS;
+    pixmap_cache_reset(display_channel->pixmap_cache, display_channel, wait);
+
+    add_buf((RedChannel *)display_channel, BUF_TYPE_RAW, wait,
+            sizeof(*wait) + wait->wait_count * sizeof(wait->wait_list[0]));
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void red_send_image(DisplayChannel *display_channel, ImageItem *item)
+{
+    RedChannel *channel;
+    RedImage *red_image;
+    RedWorker *worker;
+    Bitmap bitmap;
+
+    ASSERT(display_channel && item);
+    channel = &display_channel->base;
+    worker = channel->worker;
+
+    red_image = alloc_image(display_channel);
+    ASSERT(red_image);
+
+    QXL_SET_IMAGE_ID(red_image, QXL_IMAGE_GROUP_RED, ++worker->bits_unique);
+    red_image->descriptor.type = IMAGE_TYPE_BITMAP;
+    red_image->descriptor.flags = 0;
+    red_image->descriptor.width = item->width;
+    red_image->descriptor.height = item->height;
+
+    bitmap.format = BITMAP_FMT_32BIT;
+    bitmap.flags = QXL_BITMAP_DIRECT;
+    bitmap.flags |= item->top_down ? QXL_BITMAP_TOP_DOWN : 0;
+    bitmap.x = item->width;
+    bitmap.y = item->height;
+    bitmap.stride = item->stride;
+    bitmap.palette = 0;
+    bitmap.data = (ADDRESS)(item->data) - worker->dev_info.phys_delta;
+
+    channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
+
+    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.copy, sizeof(RedCopy));
+    display_channel->send_data.u.copy.base.box.left = item->pos.x;
+    display_channel->send_data.u.copy.base.box.top = item->pos.y;
+    display_channel->send_data.u.copy.base.box.right = item->pos.x + bitmap.x;
+    display_channel->send_data.u.copy.base.box.bottom = item->pos.y + bitmap.y;
+    display_channel->send_data.u.copy.base.clip.type = CLIP_TYPE_NONE;
+    display_channel->send_data.u.copy.base.clip.data = 0;
+    display_channel->send_data.u.copy.data.rop_decriptor = ROPD_OP_PUT;
+    display_channel->send_data.u.copy.data.src_area.left = 0;
+    display_channel->send_data.u.copy.data.src_area.top = 0;
+    display_channel->send_data.u.copy.data.src_area.right = bitmap.x;
+    display_channel->send_data.u.copy.data.src_area.bottom = bitmap.y;
+    display_channel->send_data.u.copy.data.scale_mode = 0;
+    display_channel->send_data.u.copy.data.src_bitmap = channel->send_data.header.size;
+    display_channel->send_data.u.copy.data.mask.bitmap = 0;
+
+    compress_send_data_t comp_send_data;
+
+    if (red_quic_compress_image(display_channel, red_image, &bitmap, &comp_send_data)) {
+        add_buf(channel, BUF_TYPE_RAW, red_image, comp_send_data.raw_size);
+        add_buf(channel, BUF_TYPE_COMPRESS_BUF, comp_send_data.comp_buf,
+                comp_send_data.comp_buf_size);
+    } else {
+        red_image->descriptor.type = IMAGE_TYPE_BITMAP;
+        red_image->bitmap = bitmap;
+        red_image->bitmap.flags &= ~QXL_BITMAP_DIRECT;
+        add_buf(channel, BUF_TYPE_RAW, red_image, sizeof(BitmapImage));
+        red_image->bitmap.data = channel->send_data.header.size;
+        add_buf(channel, BUF_TYPE_RAW, item->data, bitmap.y * bitmap.stride);
+    }
+    display_begin_send_massage(display_channel, &item->link);
+}
+
+static void red_display_send_upgrade(DisplayChannel *display_channel, UpgradeItem *item)
+{
+    RedChannel *channel;
+    QXLDrawable *qxl_drawable;
+    RedCopy *copy = &display_channel->send_data.u.copy;
+
+    ASSERT(display_channel && item && item->drawable);
+    channel = &display_channel->base;
+
+    channel->send_data.header.type = RED_DISPLAY_DRAW_COPY;
+
+    qxl_drawable = item->drawable->qxl_drawable;
+    ASSERT(qxl_drawable->type == QXL_DRAW_COPY);
+    ASSERT(qxl_drawable->u.copy.rop_decriptor == ROPD_OP_PUT);
+    ASSERT(qxl_drawable->u.copy.mask.bitmap == 0);
+
+    add_buf(channel, BUF_TYPE_RAW, copy, sizeof(RedCopy));
+    copy->base.box = qxl_drawable->bbox;
+    copy->base.clip.type = CLIP_TYPE_RECTS;
+    copy->base.clip.data = channel->send_data.header.size;
+    add_buf(channel, BUF_TYPE_RAW, &item->region.num_rects, sizeof(uint32_t));
+    add_buf(channel, BUF_TYPE_RAW, item->region.rects, sizeof(Rect) * item->region.num_rects);
+    copy->data = qxl_drawable->u.copy;
+    fill_bits(display_channel, &copy->data.src_bitmap, item->drawable);
+
+    display_begin_send_massage(display_channel, &item->base);
+}
+
+static void red_display_send_stream_start(DisplayChannel *display_channel, StreamAgent *agent)
+{
+    RedChannel *channel = &display_channel->base;
+    Stream *stream = agent->stream;
+
+    agent->lats_send_time = 0;
+    ASSERT(stream);
+    channel->send_data.header.type = RED_DISPLAY_STREAM_CREATE;
+    RedStreamCreate *stream_create = &display_channel->send_data.u.stream_create.message;
+    stream_create->id = agent - display_channel->stream_agents;
+    stream_create->flags = stream->top_down ? STREAM_TOP_DOWN : 0;
+    stream_create->codec_type = RED_VIDEO_CODEC_TYPE_MJPEG;
+
+    stream_create->src_width = stream->width;
+    stream_create->src_height = stream->height;
+    stream_create->stream_width = ALIGN(stream_create->src_width, 2);
+    stream_create->stream_height = ALIGN(stream_create->src_height, 2);
+    stream_create->dest = stream->dest_area;
+
+    add_buf(channel, BUF_TYPE_RAW, stream_create, sizeof(*stream_create));
+    if (stream->current) {
+        QXLDrawable *qxl_drawable = stream->current->qxl_drawable;
+        stream_create->clip = qxl_drawable->clip;
+        if (qxl_drawable->clip.type == CLIP_TYPE_RECTS) {
+            fill_rects_clip(channel, &stream_create->clip.data);
+        } else {
+            ASSERT(qxl_drawable->clip.type == CLIP_TYPE_NONE);
+        }
+        display_begin_send_massage(display_channel, &stream->current->pipe_item);
+    } else {
+        stream_create->clip.type = CLIP_TYPE_RECTS;
+        stream_create->clip.data = channel->send_data.header.size;
+        display_channel->send_data.u.stream_create.num_rects = 0;
+        add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.stream_create.num_rects,
+                sizeof(uint32_t));
+        display_begin_send_massage(display_channel, NULL);
+    }
+}
+
+static void red_display_send_stream_clip(DisplayChannel *display_channel,
+                                         StreamClipItem *item)
+{
+    RedChannel *channel = &display_channel->base;
+
+    StreamAgent *agent = item->stream_agent;
+    Stream *stream = agent->stream;
+
+    ASSERT(stream);
+
+    channel->send_data.header.type = RED_DISPLAY_STREAM_CLIP;
+    RedStreamClip *stream_clip = &display_channel->send_data.u.stream_clip;
+    add_buf(channel, BUF_TYPE_RAW, stream_clip, sizeof(*stream_clip));
+    stream_clip->id = agent - display_channel->stream_agents;
+    if ((stream_clip->clip.type = item->clip_type) == CLIP_TYPE_NONE) {
+        stream_clip->clip.data = 0;
+    } else {
+        ASSERT(stream_clip->clip.type == CLIP_TYPE_RECTS);
+        stream_clip->clip.data = channel->send_data.header.size;
+        add_buf(channel, BUF_TYPE_RAW, &item->region.num_rects, sizeof(uint32_t));
+        add_buf(channel, BUF_TYPE_RAW, item->region.rects,
+                item->region.num_rects * sizeof(Rect));
+    }
+    display_begin_send_massage(display_channel, item);
+}
+
+static void red_display_send_stream_end(DisplayChannel *display_channel, StreamAgent* agent)
+{
+    RedChannel *channel = &display_channel->base;
+    channel->send_data.header.type = RED_DISPLAY_STREAM_DESTROY;
+    display_channel->send_data.u.stream_destroy.id = agent - display_channel->stream_agents;
+    add_buf(channel, BUF_TYPE_RAW, &display_channel->send_data.u.stream_destroy,
+            sizeof(RedStreamDestroy));
+    display_begin_send_massage(display_channel, NULL);
+}
+
+static void red_cursor_send_inval(CursorChannel *channel, CacheItem *cach_item)
+{
+    ASSERT(channel);
+    red_send_inval((RedChannel *)channel, cach_item, &channel->send_data.u.inval_one);
+}
+
+static void red_send_cursor_init(CursorChannel *channel)
+{
+    RedWorker *worker;
+    ASSERT(channel);
+
+    worker = channel->base.worker;
+
+    channel->base.send_data.header.type = RED_CURSOR_INIT;
+    channel->send_data.u.cursor_init.visible = worker->cursor_visible;
+    channel->send_data.u.cursor_init.position = worker->cursor_position;
+    channel->send_data.u.cursor_init.trail_length = worker->cursor_trail_length;
+    channel->send_data.u.cursor_init.trail_frequency = worker->cursor_trail_frequency;
+    add_buf(&channel->base, BUF_TYPE_RAW, &channel->send_data.u.cursor_init, sizeof(RedCursorInit));
+
+    fill_cursor(channel, &channel->send_data.u.cursor_init.cursor, worker->cursor);
+
+    red_begin_send_massage(&channel->base, worker->cursor);
+}
+
+static void red_send_local_cursor(CursorChannel *cursor_channel, LocalCursor *cursor)
+{
+    RedChannel *channel;
+
+    ASSERT(cursor_channel);
+
+    channel = &cursor_channel->base;
+    channel->send_data.header.type = RED_CURSOR_SET;
+    cursor_channel->send_data.u.cursor_set.postition = cursor->position;
+    cursor_channel->send_data.u.cursor_set.visible = channel->worker->cursor_visible;
+    add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_set,
+            sizeof(RedCursorSet));
+    fill_cursor(cursor_channel, &cursor_channel->send_data.u.cursor_set.cursor, &cursor->base);
+
+    red_begin_send_massage(channel, cursor);
+
+    red_release_cursor(channel->worker, (CursorItem *)cursor);
+}
+
+static void cursor_channel_send_migrate(CursorChannel *cursor_channel)
+{
+    cursor_channel->base.send_data.header.type = RED_MIGRATE;
+    cursor_channel->send_data.u.migrate.flags = 0;
+    add_buf((RedChannel*)cursor_channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.migrate,
+            sizeof(cursor_channel->send_data.u.migrate));
+    red_begin_send_massage((RedChannel*)cursor_channel, NULL);
+}
+
+static void red_send_cursor(CursorChannel *cursor_channel, CursorItem *cursor)
+{
+    RedChannel *channel;
+    QXLCursorCmd *cmd;
+
+    ASSERT(cursor_channel);
+
+    channel = &cursor_channel->base;
+
+    cmd = CONTAINEROF(cursor, QXLCursorCmd, device_data);
+    switch (cmd->type) {
+    case QXL_CURSOR_MOVE:
+        channel->send_data.header.type = RED_CURSOR_MOVE;
+        cursor_channel->send_data.u.cursor_move.postition = cmd->u.position;
+        add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_move,
+                sizeof(RedCursorMove));
+        break;
+    case QXL_CURSOR_SET:
+        channel->send_data.header.type = RED_CURSOR_SET;
+        cursor_channel->send_data.u.cursor_set.postition = cmd->u.set.position;
+        cursor_channel->send_data.u.cursor_set.visible = channel->worker->cursor_visible;
+        add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_set,
+                sizeof(RedCursorSet));
+        fill_cursor(cursor_channel, &cursor_channel->send_data.u.cursor_set.cursor, cursor);
+        break;
+    case QXL_CURSOR_HIDE:
+        channel->send_data.header.type = RED_CURSOR_HIDE;
+        break;
+    case QXL_CURSOR_TRAIL:
+        channel->send_data.header.type = RED_CURSOR_TRAIL;
+        cursor_channel->send_data.u.cursor_trail.length = cmd->u.trail.length;
+        cursor_channel->send_data.u.cursor_trail.frequency = cmd->u.trail.frequency;
+        add_buf(channel, BUF_TYPE_RAW, &cursor_channel->send_data.u.cursor_trail,
+                sizeof(RedCursorTrail));
+        break;
+    default:
+        red_error("bad cursor command %d", cmd->type);
+    }
+
+    red_begin_send_massage(channel, cursor);
+
+    red_release_cursor(channel->worker, cursor);
+}
+
+static inline PipeItem *red_pipe_get(RedChannel *channel)
+{
+    PipeItem *item;
+    if (!channel || channel->send_data.blocked ||
+                                            !(item = (PipeItem *)ring_get_tail(&channel->pipe))) {
+        return NULL;
+    }
+
+    if (channel->messages_window > channel->client_ack_window * 2) {
+        channel->send_data.blocked = TRUE;
+        return NULL;
+    }
+
+    --channel->pipe_size;
+    ring_remove(&item->link);
+    return item;
+}
+
+static void display_channel_push(RedWorker *worker)
+{
+    PipeItem *pipe_item;
+
+    while ((pipe_item = red_pipe_get((RedChannel *)worker->display_channel))) {
+        DisplayChannel *display_channel;
+        display_channel = (DisplayChannel *)red_ref_channel((RedChannel *)worker->display_channel);
+        red_display_reset_send_data(display_channel);
+        switch (pipe_item->type) {
+        case PIPE_ITEM_TYPE_DRAW: {
+            Drawable *drawable = CONTAINEROF(pipe_item, Drawable, pipe_item);
+            send_qxl_drawable(display_channel, drawable);
+            release_drawable(worker, drawable);
+            break;
+        }
+        case PIPE_ITEM_TYPE_INVAL_ONE:
+            red_display_send_inval(display_channel, (CacheItem *)pipe_item);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_STREAM_CREATE: {
+            StreamAgent *agent = CONTAINEROF(pipe_item, StreamAgent, create_item);
+            red_display_send_stream_start(display_channel, agent);
+            red_display_release_stream(display_channel, agent);
+            break;
+        }
+        case PIPE_ITEM_TYPE_STREAM_CLIP: {
+            StreamClipItem* clip_item = (StreamClipItem *)pipe_item;
+            red_display_send_stream_clip(display_channel, clip_item);
+            red_display_release_stream_clip(display_channel, clip_item);
+            break;
+        }
+        case PIPE_ITEM_TYPE_STREAM_DESTROY: {
+            StreamAgent *agent = CONTAINEROF(pipe_item, StreamAgent, destroy_item);
+            red_display_send_stream_end(display_channel, agent);
+            red_display_release_stream(display_channel, agent);
+            break;
+        }
+        case PIPE_ITEM_TYPE_UPGRADE:
+            red_display_send_upgrade(display_channel, (UpgradeItem *)pipe_item);
+            release_upgrade_item(worker, (UpgradeItem *)pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_VERB:
+            display_send_verb(display_channel, ((VerbItem*)pipe_item)->verb);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_MODE:
+            red_send_mode(display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_MIGRATE:
+            red_printf("PIPE_ITEM_TYPE_MIGRATE");
+            display_channel_send_migrate(display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_MIGRATE_DATA:
+            display_channel_send_migrate_data(display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_SET_ACK:
+            red_send_set_ack((RedChannel *)display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_IMAGE:
+            red_send_image(display_channel, (ImageItem *)pipe_item);
+            release_image_item((ImageItem *)pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_PIXMAP_SYNC:
+            display_channel_pixmap_sync(display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_PIXMAP_RESET:
+            display_channel_reset_cache(display_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_INVAL_PALLET_CACHE:
+            red_reset_palette_cache(display_channel);
+            red_send_verb((RedChannel *)display_channel, RED_DISPLAY_INVAL_ALL_PALETTES);
+            free(pipe_item);
+            break;
+        default:
+            red_error("invalid pipe item type");
+        }
+        red_unref_channel((RedChannel *)display_channel);
+    }
+}
+
+static void cursor_channel_push(RedWorker *worker)
+{
+    PipeItem *pipe_item;
+
+    while ((pipe_item = red_pipe_get((RedChannel *)worker->cursor_channel))) {
+        CursorChannel *cursor_channel;
+
+        cursor_channel = (CursorChannel *)red_ref_channel((RedChannel *)worker->cursor_channel);
+        red_channel_reset_send_data((RedChannel*)cursor_channel);
+        switch (pipe_item->type) {
+        case PIPE_ITEM_TYPE_CURSOR:
+            red_send_cursor(cursor_channel, (CursorItem *)pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_LOCAL_CURSOR:
+            red_send_local_cursor(cursor_channel, (LocalCursor *)pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_INVAL_ONE:
+            red_cursor_send_inval(cursor_channel, (CacheItem *)pipe_item);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_VERB:
+            red_send_verb((RedChannel *)cursor_channel, ((VerbItem*)pipe_item)->verb);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_MIGRATE:
+            red_printf("PIPE_ITEM_TYPE_MIGRATE");
+            cursor_channel_send_migrate(cursor_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_SET_ACK:
+            red_send_set_ack((RedChannel *)cursor_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_CURSOR_INIT:
+            red_send_cursor_init(cursor_channel);
+            free(pipe_item);
+            break;
+        case PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE:
+            red_reset_cursor_cache(cursor_channel);
+            red_send_verb((RedChannel *)cursor_channel, RED_CURSOR_INVAL_ALL);
+            free(pipe_item);
+            break;
+        default:
+            red_error("invalid pipe item type");
+        }
+        red_unref_channel((RedChannel *)cursor_channel);
+    }
+}
+
+static inline void red_push(RedWorker *worker)
+{
+    cursor_channel_push(worker);
+    display_channel_push(worker);
+}
+
+typedef struct ShowTreeData {
+    RedWorker *worker;
+    int level;
+    Container *container;
+} ShowTreeData;
+
+static void __show_tree_call(TreeItem *item, void *data)
+{
+    ShowTreeData *tree_data = data;
+    const char *item_prefix = "|--";
+    int i;
+
+    while (tree_data->container != item->container) {
+        ASSERT(tree_data->container);
+        tree_data->level--;
+        tree_data->container = tree_data->container->base.container;
+    }
+
+    switch (item->type) {
+    case TREE_ITEM_TYPE_DRAWABLE: {
+        Drawable *drawable = CONTAINEROF(item, Drawable, tree_item);
+        const int max_indent = 200;
+        char indent_str[max_indent + 1];
+        int indent_str_len;
+
+        for (i = 0; i < tree_data->level; i++) {
+            printf("  ");
+        }
+        printf(item_prefix, 0);
+        show_qxl_drawable(tree_data->worker, drawable->qxl_drawable, NULL);
+        for (i = 0; i < tree_data->level; i++) {
+            printf("  ");
+        }
+        printf("|  ");
+        show_draw_item(tree_data->worker, &drawable->tree_item, NULL);
+        indent_str_len = MIN(max_indent, strlen(item_prefix) + tree_data->level * 2);
+        memset(indent_str, ' ', indent_str_len);
+        indent_str[indent_str_len] = 0;
+        region_dump(&item->rgn, indent_str);
+        printf("\n");
+        break;
+    }
+    case TREE_ITEM_TYPE_CONTAINER:
+        tree_data->level++;
+        tree_data->container = (Container *)item;
+        break;
+    case TREE_ITEM_TYPE_SHADOW:
+        break;
+    }
+}
+
+void red_show_tree(RedWorker *worker)
+{
+    ShowTreeData show_tree_data;
+    show_tree_data.worker = worker;
+    show_tree_data.level = 0;
+    show_tree_data.container = NULL;
+    current_tree_for_each(worker, __show_tree_call, &show_tree_data);
+}
+
+static inline int channel_is_connected(RedChannel *channel)
+{
+    return !!channel->peer;
+}
+
+static void red_disconnect_channel(RedChannel *channel)
+{
+    channel_release_res(channel);
+    red_pipe_clear(channel);
+
+    channel->peer->cb_free(channel->peer);
+
+    channel->peer = NULL;
+    channel->send_data.blocked = FALSE;
+    channel->send_data.size = channel->send_data.pos = 0;
+    red_unref_channel(channel);
+}
+
+static void red_disconnect_display(RedChannel *channel)
+{
+    DisplayChannel *display_channel;
+
+    if (!channel || !channel->peer) {
+        return;
+    }
+
+    display_channel = (DisplayChannel *)channel;
+    ASSERT(display_channel == channel->worker->display_channel);
+#ifdef COMPRESS_STAT
+    print_compress_stats(display_channel);
+#endif
+    channel->worker->display_channel = NULL;
+    red_display_unshare_stream_buf(display_channel);
+    red_release_pixmap_cache(display_channel);
+    red_release_glz(display_channel);
+    red_reset_palette_cache(display_channel);
+    free(display_channel->send_data.stream_outbuf);
+    red_display_reset_compress_buf(display_channel);
+    while (display_channel->send_data.free_compress_bufs) {
+        RedCompressBuf *buf = display_channel->send_data.free_compress_bufs;
+        display_channel->send_data.free_compress_bufs = buf->next;
+        free(buf);
+    }
+    free(display_channel->send_data.free_list.res);
+    red_display_destroy_streams(display_channel);
+    red_disconnect_channel(channel);
+}
+
+static void red_migrate_display(RedWorker *worker)
+{
+    if (worker->display_channel) {
+        red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_STREAM_DESTROY_ALL);
+        red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_MIGRATE);
+    }
+}
+
+static void destroy_cairo_canvas(CairoCanvas *canvas)
+{
+    cairo_t *cairo;
+
+    if (!canvas) {
+        return;
+    }
+
+    cairo = canvas_get_cairo(canvas);
+    canvas_destroy(canvas);
+    cairo_destroy(cairo);
+}
+
+static void validate_area_nop(void *canvas, const DrawArea *draw_area, const Rect *area)
+{
+}
+
+static void init_cairo_draw_context(RedWorker *worker, CairoCanvas *canvas)
+{
+    worker->draw_context.canvas = canvas;
+    worker->draw_context.top_down = TRUE;
+    worker->draw_context.set_access_params = (set_access_params_t)canvas_set_access_params;
+    worker->draw_context.draw_fill = (draw_fill_t)canvas_draw_fill;
+    worker->draw_context.draw_copy = (draw_copy_t)canvas_draw_copy;
+    worker->draw_context.draw_opaque = (draw_opaque_t)canvas_draw_opaque;
+    worker->draw_context.copy_bits = (copy_bits_t)canvas_copy_bits;
+    worker->draw_context.draw_text = (draw_text_t)canvas_draw_text;
+    worker->draw_context.draw_stroke = (draw_stroke_t)canvas_draw_stroke;
+    worker->draw_context.draw_rop3 = (draw_rop3_t)canvas_draw_rop3;
+    worker->draw_context.draw_blend = (draw_blend_t)canvas_draw_blend;
+    worker->draw_context.draw_blackness = (draw_blackness_t)canvas_draw_blackness;
+    worker->draw_context.draw_whiteness = (draw_whiteness_t)canvas_draw_whiteness;
+    worker->draw_context.draw_invers = (draw_invers_t)canvas_draw_invers;
+    worker->draw_context.draw_transparent = (draw_transparent_t)canvas_draw_transparent;
+    worker->draw_context.draw_alpha_blend = (draw_alpha_blend_t)canvas_draw_alpha_blend;
+    worker->draw_context.read_pixels = (read_pixels_t)canvas_read_bits;
+
+    worker->draw_context.set_top_mask = (set_top_mask_t)canvas_group_start;
+    worker->draw_context.clear_top_mask = (clear_top_mask_t)canvas_group_end;
+    worker->draw_context.validate_area = validate_area_nop;
+    worker->draw_context.destroy = (destroy_t)destroy_cairo_canvas;
+}
+
+static int create_cairo_context(RedWorker *worker)
+{
+    cairo_surface_t *cairo_surface;
+    CairoCanvas *canvas;
+    cairo_t *cairo;
+
+    cairo_surface = cairo_image_surface_create_for_data(worker->dev_info.draw_area.line_0,
+                                                        CAIRO_FORMAT_RGB24,
+                                                        worker->dev_info.draw_area.width,
+                                                        worker->dev_info.draw_area.heigth,
+                                                        worker->dev_info.draw_area.stride);
+
+    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+        red_error("create cairo surface failed, %s",
+                  cairo_status_to_string(cairo_surface_status(cairo_surface)));
+    }
+    cairo = cairo_create(cairo_surface);
+    cairo_surface_destroy(cairo_surface);
+    if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
+        red_error("create cairo failed, %s",
+                  cairo_status_to_string(cairo_status(cairo)));
+    }
+
+    if (!(canvas = canvas_create(cairo, worker->dev_info.bits, &worker->image_cache,
+                                 image_cache_put, image_cache_get))) {
+        red_error("create cairo canvas failed");
+    }
+    init_cairo_draw_context(worker, canvas);
+    red_printf("using cairo canvas");
+    return TRUE;
+}
+
+static void destroy_gl_canvas(GLCanvas *canvas)
+{
+    OGLCtx *ctx;
+
+    if (!canvas) {
+        return;
+    }
+
+    ctx = gl_canvas_get_usr_data(canvas);
+    ASSERT(ctx);
+    gl_canvas_destroy(canvas, 0);
+    oglctx_destroy(ctx);
+}
+
+static void gl_validate_area(GLCanvas *canvas, DrawArea *draw_area, const Rect *area)
+{
+    int h;
+
+    if (!(h = area->bottom - area->top)) {
+        return;
+    }
+
+    ASSERT(draw_area->stride < 0);
+    uint8_t *dest = draw_area->line_0 + (area->top * draw_area->stride) +
+                    area->left * sizeof(uint32_t);
+    dest += (h - 1) * draw_area->stride;
+    gl_canvas_read_pixels(canvas, dest, -draw_area->stride, area);
+}
+
+static void init_ogl_draw_context(RedWorker *worker, GLCanvas *canvas)
+{
+    worker->draw_context.canvas = canvas;
+    worker->draw_context.top_down = FALSE;
+    worker->draw_context.set_access_params = (set_access_params_t)gl_canvas_set_access_params;
+    worker->draw_context.draw_fill = (draw_fill_t)gl_canvas_draw_fill;
+    worker->draw_context.draw_copy = (draw_copy_t)gl_canvas_draw_copy;
+    worker->draw_context.draw_opaque = (draw_opaque_t)gl_canvas_draw_opaque;
+    worker->draw_context.copy_bits = (copy_bits_t)gl_canvas_copy_pixels;
+    worker->draw_context.draw_text = (draw_text_t)gl_canvas_draw_text;
+    worker->draw_context.draw_stroke = (draw_stroke_t)gl_canvas_draw_stroke;
+    worker->draw_context.draw_rop3 = (draw_rop3_t)gl_canvas_draw_rop3;
+    worker->draw_context.draw_blend = (draw_blend_t)gl_canvas_draw_blend;
+    worker->draw_context.draw_blackness = (draw_blackness_t)gl_canvas_draw_blackness;
+    worker->draw_context.draw_whiteness = (draw_whiteness_t)gl_canvas_draw_whiteness;
+    worker->draw_context.draw_invers = (draw_invers_t)gl_canvas_draw_invers;
+    worker->draw_context.draw_transparent = (draw_transparent_t)gl_canvas_draw_transparent;
+    worker->draw_context.draw_alpha_blend = (draw_alpha_blend_t)gl_canvas_draw_alpha_blend;
+    worker->draw_context.read_pixels = (read_pixels_t)gl_canvas_read_pixels;
+
+    worker->draw_context.set_top_mask = (set_top_mask_t)gl_canvas_set_top_mask;
+    worker->draw_context.clear_top_mask = (clear_top_mask_t)gl_canvas_clear_top_mask;
+    worker->draw_context.validate_area = (validate_area_t)gl_validate_area;
+    worker->draw_context.destroy = (destroy_t)destroy_gl_canvas;
+}
+
+static int create_ogl_context_common(RedWorker *worker, OGLCtx *ctx)
+{
+    GLCanvas *canvas;
+    int width;
+    int height;
+
+    width = worker->dev_info.x_res;
+    height = worker->dev_info.y_res;
+
+    oglctx_make_current(ctx);
+    if (!(canvas = gl_canvas_create(ctx, width, height, worker->dev_info.bits, &worker->image_cache,
+                                    image_cache_put, image_cache_get))) {
+        return FALSE;
+    }
+
+    init_ogl_draw_context(worker, canvas);
+    gl_canvas_clear(canvas);
+    red_printf("using ogl %s canvas", oglctx_type_str(ctx));
+    return TRUE;
+}
+
+static int create_ogl_pbuf_context(RedWorker *worker)
+{
+    OGLCtx *ctx;
+
+    if (!(ctx = pbuf_create(worker->dev_info.x_res, worker->dev_info.y_res))) {
+        return FALSE;
+    }
+
+    if (!create_ogl_context_common(worker, ctx)) {
+        oglctx_destroy(ctx);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static int create_ogl_pixmap_context(RedWorker *worker)
+{
+    OGLCtx *ctx;
+
+    if (!(ctx = pixmap_create(worker->dev_info.x_res, worker->dev_info.y_res))) {
+        return FALSE;
+    }
+
+    if (!create_ogl_context_common(worker, ctx)) {
+        oglctx_destroy(ctx);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static void red_create_draw_context(RedWorker *worker)
+{
+    int i;
+
+    worker->draw_context.destroy(worker->draw_context.canvas);
+    worker->draw_context.canvas = NULL;
+    for (i = 0; i < worker->num_renderers; i++) {
+        switch (worker->renderers[i]) {
+        case RED_RENDERER_CAIRO:
+            if (create_cairo_context(worker)) {
+                return;
+            }
+            break;
+        case RED_RENDERER_OGL_PBUF:
+            if (create_ogl_pbuf_context(worker)) {
+                return;
+            }
+            break;
+        case RED_RENDERER_OGL_PIXMAP:
+            if (create_ogl_pixmap_context(worker)) {
+                return;
+            }
+            break;
+        default:
+            red_error("invalid renderer type");
+        }
+    }
+    red_error("create renderer failed");
+    memset(worker->dev_info.draw_area.buf, 0, worker->dev_info.draw_area.size);
+}
+
+static void push_new_mode(RedWorker *worker)
+{
+    DisplayChannel *display_channel;
+
+    if ((display_channel = worker->display_channel)) {
+        red_pipe_add_type(&display_channel->base, PIPE_ITEM_TYPE_INVAL_PALLET_CACHE);
+        if (!display_channel->base.migrate) {
+            red_pipe_add_type(&display_channel->base, PIPE_ITEM_TYPE_MODE);
+        }
+        display_channel_push(worker);
+    }
+}
+
+static int display_channel_wait_for_init(DisplayChannel *display_channel)
+{
+    display_channel->expect_init = TRUE;
+    uint64_t end_time = red_now() + DISPLAY_CLIENT_TIMEOUT;
+    for (;;) {
+        red_receive((RedChannel *)display_channel);
+        if (!display_channel->base.peer) {
+            break;
+        }
+        if (display_channel->pixmap_cache && display_channel->glz_dict) {
+            display_channel->pixmap_cache_generation = display_channel->pixmap_cache->generation;
+            display_channel->glz = glz_encoder_create(display_channel->base.id,
+                                                      display_channel->glz_dict->dict,
+                                                      &display_channel->glz_data.usr);
+            if (!display_channel->glz) {
+                PANIC("create global lz failed");
+            }
+            return TRUE;
+        }
+        if (red_now() > end_time) {
+            red_printf("timeout");
+            red_disconnect_display((RedChannel *)display_channel);
+            break;
+        }
+        usleep(DISPLAY_CLIENT_RETRY_INTERVAL);
+    }
+    return FALSE;
+}
+
+static void on_new_display_channel(RedWorker *worker)
+{
+    DisplayChannel *display_channel = worker->display_channel;
+    ASSERT(display_channel);
+
+    red_pipe_add_type(&display_channel->base, PIPE_ITEM_TYPE_SET_ACK);
+
+    if (display_channel->base.migrate) {
+        display_channel->expect_migrate_data = TRUE;
+        return;
+    }
+
+    if (!display_channel_wait_for_init(display_channel)) {
+        return;
+    }
+    display_channel->base.messages_window = 0;
+    if (worker->attached) {
+        red_current_flush(worker);
+        push_new_mode(worker);
+        red_add_screen_image(worker);
+        if (channel_is_connected(&display_channel->base)) {
+            red_pipe_add_verb(&display_channel->base, RED_DISPLAY_MARK);
+            red_disply_start_streams(display_channel);
+        }
+    }
+}
+
+static int channel_handle_message(RedChannel *channel, RedDataHeader *message)
+{
+    switch (message->type) {
+    case REDC_ACK_SYNC:
+        if (message->size != sizeof(uint32_t)) {
+            red_printf("bad message size");
+            return FALSE;
+        }
+        channel->client_ack_generation = *(uint32_t *)(message + 1);
+        break;
+    case REDC_ACK:
+        if (channel->client_ack_generation == channel->ack_generation) {
+            channel->messages_window -= channel->client_ack_window;
+        }
+        break;
+    case REDC_DISCONNECTING:
+        break;
+    default:
+        red_printf("invalid message type %u", message->type);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static GlzSharedDictionary *_red_find_glz_dictionary(uint8_t dict_id)
+{
+    RingItem *now;
+    GlzSharedDictionary *ret = NULL;
+
+    now = &glz_dictionary_list;
+
+    while ((now = ring_next(&glz_dictionary_list, now))) {
+        if (((GlzSharedDictionary *)now)->id == dict_id) {
+            ret = (GlzSharedDictionary *)now;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+static GlzSharedDictionary *_red_create_glz_dictionary(DisplayChannel *display,
+                                                       uint8_t id,
+                                                       GlzEncDictContext *opaque_dict)
+{
+    GlzSharedDictionary *shared_dict = malloc(sizeof(*shared_dict));
+    memset(shared_dict, 0, sizeof(*shared_dict)); // nullify the ring base
+
+    if (!shared_dict) {
+        return NULL;
+    }
+    shared_dict->dict = opaque_dict;
+    shared_dict->id = id;
+    shared_dict->refs = 1;
+    shared_dict->migrate_freeze = FALSE;
+    ring_item_init(&shared_dict->base);
+    pthread_rwlock_init(&shared_dict->encode_lock, NULL);
+    return shared_dict;
+}
+
+static GlzSharedDictionary *red_create_glz_dictionary(DisplayChannel *display,
+                                                      uint8_t id, int window_size)
+{
+    GlzEncDictContext *glz_dict = glz_enc_dictionary_create(window_size,
+                                                            MAX_LZ_ENCODERS,
+                                                            &display->glz_data.usr);
+#ifdef COMPRESS_DEBUG
+    red_printf("Lz Window %d Size=%d", id, window_size);
+#endif
+    if (!glz_dict) {
+        PANIC("failed creating lz dictionary");
+        return NULL;
+    }
+    return _red_create_glz_dictionary(display, id, glz_dict);
+}
+
+static GlzSharedDictionary *red_create_restored_glz_dictionary(DisplayChannel *display,
+                                                               uint8_t id,
+                                                               GlzEncDictRestoreData *restore_data)
+{
+    GlzEncDictContext *glz_dict = glz_enc_dictionary_restore(restore_data,
+                                                             &display->glz_data.usr);
+    if (!glz_dict) {
+        PANIC("failed creating lz dictionary");
+        return NULL;
+    }
+    return _red_create_glz_dictionary(display, id, glz_dict);
+}
+
+static GlzSharedDictionary *red_get_glz_dictionary(DisplayChannel *display,
+                                                   uint8_t id, int window_size)
+{
+    GlzSharedDictionary *shared_dict = NULL;
+
+    pthread_mutex_lock(&glz_dictionary_list_lock);
+
+    shared_dict = _red_find_glz_dictionary(id);
+
+    if (!shared_dict) {
+        shared_dict = red_create_glz_dictionary(display, id, window_size);
+        ring_add(&glz_dictionary_list, &shared_dict->base);
+    } else {
+        shared_dict->refs++;
+    }
+    pthread_mutex_unlock(&glz_dictionary_list_lock);
+    return shared_dict;
+}
+
+static GlzSharedDictionary *red_restore_glz_dictionary(DisplayChannel *display,
+                                                       uint8_t id,
+                                                       GlzEncDictRestoreData *restore_data)
+{
+    GlzSharedDictionary *shared_dict = NULL;
+
+    pthread_mutex_lock(&glz_dictionary_list_lock);
+
+    shared_dict = _red_find_glz_dictionary(id);
+
+    if (!shared_dict) {
+        shared_dict = red_create_restored_glz_dictionary(display, id, restore_data);
+        ring_add(&glz_dictionary_list, &shared_dict->base);
+    } else {
+        shared_dict->refs++;
+    }
+    pthread_mutex_unlock(&glz_dictionary_list_lock);
+    return shared_dict;
+}
+
+static void red_freeze_glz(DisplayChannel *channel)
+{
+    pthread_rwlock_wrlock(&channel->glz_dict->encode_lock);
+    if (!channel->glz_dict->migrate_freeze) {
+        channel->glz_dict->migrate_freeze = TRUE;
+    }
+    pthread_rwlock_unlock(&channel->glz_dict->encode_lock);
+}
+
+/* destroy encoder, and dictionary if no one uses it*/
+static void red_release_glz(DisplayChannel *channel)
+{
+    GlzSharedDictionary *shared_dict;
+
+    red_display_clear_glz_drawables(channel);
+
+    glz_encoder_destroy(channel->glz);
+    channel->glz = NULL;
+
+    if (!(shared_dict = channel->glz_dict)) {
+        return;
+    }
+
+    channel->glz_dict = NULL;
+    pthread_mutex_lock(&cache_lock);
+    if (--shared_dict->refs) {
+        pthread_mutex_unlock(&cache_lock);
+        return;
+    }
+    ring_remove(&shared_dict->base);
+    pthread_mutex_unlock(&cache_lock);
+    glz_enc_dictionary_destroy(shared_dict->dict, &channel->glz_data.usr);
+    free(shared_dict);
+}
+
+static PixmapCache *red_create_pixmap_cache(uint8_t id, int64_t size)
+{
+    PixmapCache *cache = malloc(sizeof(*cache));
+    if (!cache) {
+        return NULL;
+    }
+    memset(cache, 0, sizeof(*cache));
+    ring_item_init(&cache->base);
+    pthread_mutex_init(&cache->lock, NULL);
+    cache->id = id;
+    cache->refs = 1;
+    ring_init(&cache->lru);
+    cache->available = size;
+    cache->size = size;
+    return cache;
+}
+
+static PixmapCache *red_get_pixmap_cache(uint8_t id, int64_t size)
+{
+    PixmapCache *cache = NULL;
+    RingItem *now;
+    pthread_mutex_lock(&cache_lock);
+
+    now = &pixmap_cache_list;
+    while ((now = ring_next(&pixmap_cache_list, now))) {
+        if (((PixmapCache *)now)->id == id) {
+            cache = (PixmapCache *)now;
+            cache->refs++;
+            break;
+        }
+    }
+    if (!cache) {
+        cache = red_create_pixmap_cache(id, size);
+        ring_add(&pixmap_cache_list, &cache->base);
+    }
+    pthread_mutex_unlock(&cache_lock);
+    return cache;
+}
+
+static void red_release_pixmap_cache(DisplayChannel *channel)
+{
+    PixmapCache *cache;
+    if (!(cache = channel->pixmap_cache)) {
+        return;
+    }
+    channel->pixmap_cache = NULL;
+    pthread_mutex_lock(&cache_lock);
+    if (--cache->refs) {
+        pthread_mutex_unlock(&cache_lock);
+        return;
+    }
+    ring_remove(&cache->base);
+    pthread_mutex_unlock(&cache_lock);
+    pixmap_cache_destroy(cache);
+    free(cache);
+}
+
+static int display_channel_init_cache(DisplayChannel *channel, RedcDisplayInit *init_info)
+{
+    ASSERT(!channel->pixmap_cache);
+    return !!(channel->pixmap_cache = red_get_pixmap_cache(init_info->pixmap_cache_id,
+                                                           init_info->pixmap_cache_size));
+}
+
+static int display_channel_init_glz_dictionary(DisplayChannel *channel, RedcDisplayInit *init_info)
+{
+    ASSERT(!channel->glz_dict);
+    ring_init(&channel->glz_drawables);
+    ring_init(&channel->glz_drawables_inst_to_free);
+    pthread_mutex_init(&channel->glz_drawables_inst_to_free_lock, NULL);
+    return !!(channel->glz_dict = red_get_glz_dictionary(channel,
+                                                         init_info->glz_dictionary_id,
+                                                         init_info->glz_dictionary_window_size));
+}
+
+static int display_channel_init(DisplayChannel *channel, RedcDisplayInit *init_info)
+{
+    return (display_channel_init_cache(channel, init_info) &&
+            display_channel_init_glz_dictionary(channel, init_info));
+}
+
+static int display_channel_handle_migrate_glz_dictionary(DisplayChannel *channel,
+                                                         DisplayChannelMigrateData *migrate_info)
+{
+    ASSERT(!channel->glz_dict);
+    ring_init(&channel->glz_drawables);
+    ring_init(&channel->glz_drawables_inst_to_free);
+    pthread_mutex_init(&channel->glz_drawables_inst_to_free_lock, NULL);
+    return !!(channel->glz_dict = red_restore_glz_dictionary(channel,
+                                                             migrate_info->glz_dict_id,
+                                                             &migrate_info->glz_dict_restore_data));
+}
+
+static int display_channel_handle_migrate_mark(DisplayChannel *channel)
+{
+    if (!channel->expect_migrate_mark) {
+        red_printf("unexpected");
+        return FALSE;
+    }
+    channel->expect_migrate_mark = FALSE;
+    red_pipe_add_type((RedChannel *)channel, PIPE_ITEM_TYPE_MIGRATE_DATA);
+    return TRUE;
+}
+
+static int display_channel_handle_migrate_data(DisplayChannel *channel, RedDataHeader *message)
+{
+    DisplayChannelMigrateData *migrate_data;
+    int i;
+
+    if (!channel->expect_migrate_data) {
+        red_printf("unexpected");
+        return FALSE;
+    }
+    channel->expect_migrate_data = FALSE;
+    if (message->size < sizeof(*migrate_data)) {
+        red_printf("bad message size");
+        return FALSE;
+    }
+    migrate_data = (DisplayChannelMigrateData *)(message + 1);
+    if (migrate_data->magic != DISPLAY_MIGRATE_DATA_MAGIC ||
+                                            migrate_data->version != DISPLAY_MIGRATE_DATA_VERSION) {
+        red_printf("invalid content");
+        return FALSE;
+    }
+    ASSERT(channel->base.send_data.header.serial == 0);
+    channel->base.send_data.header.serial = migrate_data->message_serial;
+    if (!(channel->pixmap_cache = red_get_pixmap_cache(migrate_data->pixmap_cache_id, -1))) {
+        return FALSE;
+    }
+    pthread_mutex_lock(&channel->pixmap_cache->lock);
+    for (i = 0; i < MAX_CACHE_CLIENTS; i++) {
+        channel->pixmap_cache->sync[i] = MAX(channel->pixmap_cache->sync[i],
+                                             migrate_data->pixmap_cache_clients[i]);
+    }
+    pthread_mutex_unlock(&channel->pixmap_cache->lock);
+
+    if (migrate_data->pixmap_cache_freezer) {
+        channel->pixmap_cache->size = migrate_data->pixmap_cache_size;
+        red_pipe_add_type((RedChannel *)channel, PIPE_ITEM_TYPE_PIXMAP_RESET);
+    }
+
+    if (display_channel_handle_migrate_glz_dictionary(channel, migrate_data)) {
+        channel->glz = glz_encoder_create(channel->base.id,
+                                          channel->glz_dict->dict, &channel->glz_data.usr);
+        if (!channel->glz) {
+            PANIC("create global lz failed");
+        }
+    } else {
+        PANIC("restoring global lz dictionary failed");
+    }
+
+    channel->base.messages_window = 0;
+    return TRUE;
+}
+
+static int display_channel_handle_message(RedChannel *channel, RedDataHeader *message)
+{
+    switch (message->type) {
+    case REDC_DISPLAY_INIT:
+        if (message->size != sizeof(RedcDisplayInit)) {
+            red_printf("bad message size");
+            return FALSE;
+        }
+        if (!((DisplayChannel *)channel)->expect_init) {
+            red_printf("unexpected REDC_DISPLAY_INIT");
+            return FALSE;
+        }
+        ((DisplayChannel *)channel)->expect_init = FALSE;
+        return display_channel_init((DisplayChannel *)channel, (RedcDisplayInit *)(message + 1));
+    case REDC_MIGRATE_FLUSH_MARK:
+        return display_channel_handle_migrate_mark((DisplayChannel *)channel);
+    case REDC_MIGRATE_DATA:
+        return display_channel_handle_migrate_data((DisplayChannel *)channel, message);
+    default:
+        return channel_handle_message(channel, message);
+    }
+}
+
+static void red_receive(RedChannel *channel)
+{
+    for (;;) {
+        ssize_t n;
+        n = channel->recive_data.end - channel->recive_data.now;
+        ASSERT(n);
+        ASSERT(channel->peer);
+        if ((n = channel->peer->cb_read(channel->peer->ctx, channel->recive_data.now, n)) <= 0) {
+            if (n == 0) {
+                channel->disconnect(channel);
+                return;
+            }
+            ASSERT(n == -1);
+            switch (errno) {
+            case EAGAIN:
+                return;
+            case EINTR:
+                break;
+            case EPIPE:
+                channel->disconnect(channel);
+                return;
+            default:
+                red_printf("%s", strerror(errno));
+                channel->disconnect(channel);
+                return;
+            }
+        } else {
+            channel->recive_data.now += n;
+            for (;;) {
+                RedDataHeader *message = channel->recive_data.message;
+                n = channel->recive_data.now - (uint8_t *)message;
+                if (n < sizeof(RedDataHeader) ||
+                    n < sizeof(RedDataHeader) + message->size) {
+                    break;
+                }
+                if (!channel->handle_message(channel, message)) {
+                    channel->disconnect(channel);
+                    return;
+                }
+                channel->recive_data.message = (RedDataHeader *)((uint8_t *)message +
+                                                                 sizeof(RedDataHeader) +
+                                                                 message->size);
+            }
+
+            if (channel->recive_data.now == (uint8_t *)channel->recive_data.message) {
+                channel->recive_data.now = channel->recive_data.buf;
+                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+            } else if (channel->recive_data.now == channel->recive_data.end) {
+                memcpy(channel->recive_data.buf, channel->recive_data.message, n);
+                channel->recive_data.now = channel->recive_data.buf + n;
+                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+            }
+        }
+    }
+}
+
+static RedChannel *__new_channel(RedWorker *worker, int size, RedsStreamContext *peer, int migrate,
+                                 event_listener_action_proc handler,
+                                 disconnect_channel_proc disconnect,
+                                 hold_item_proc hold_item,
+                                 release_item_proc release_item,
+                                 handle_message_proc handle_message)
+{
+    struct epoll_event event;
+    RedChannel *channel;
+    int flags;
+    int delay_val;
+
+    if ((flags = fcntl(peer->socket, F_GETFL)) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    if (fcntl(peer->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    delay_val = IS_LOW_BANDWIDTH() ? 0 : 1;
+    if (setsockopt(peer->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    ASSERT(size >= sizeof(*channel));
+    if (!(channel = malloc(size))) {
+        red_printf("malloc failed");
+        goto error1;
+    }
+    memset(channel, 0, size);
+    channel->id = worker->id;
+    channel->listener.refs = 1;
+    channel->listener.action = handler;
+    channel->disconnect = disconnect;
+    channel->hold_item = hold_item;
+    channel->release_item = release_item;
+    channel->handle_message = handle_message;
+    channel->peer = peer;
+    channel->worker = worker;
+    channel->messages_window = ~0;  // blocks send message (maybe use send_data.blocked +
+                                    // block flags)
+    channel->client_ack_window = IS_LOW_BANDWIDTH() ? WIDE_CLIENT_ACK_WINDOW :
+                                                      NARROW_CLIENT_ACK_WINDOW;
+    channel->client_ack_generation = ~0;
+    channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+    channel->recive_data.now = channel->recive_data.buf;
+    channel->recive_data.end = channel->recive_data.buf + sizeof(channel->recive_data.buf);
+    ring_init(&channel->pipe);
+
+    event.events = EPOLLIN | EPOLLOUT | EPOLLET;
+    event.data.ptr = channel;
+    if (epoll_ctl(worker->epoll, EPOLL_CTL_ADD, peer->socket, &event) == -1) {
+        red_printf("epoll_ctl failed, %s", strerror(errno));
+        goto error2;
+    }
+
+    channel->migrate = migrate;
+    return channel;
+
+error2:
+    free(channel);
+error1:
+    peer->cb_free(peer);
+
+    return NULL;
+}
+
+static void handle_channel_events(EventListener *in_listener, uint32_t events)
+{
+    RedChannel *channel = (RedChannel *)in_listener;
+
+    if ((events & EPOLLIN)) {
+        red_receive(channel);
+    }
+
+    if (channel->send_data.blocked) {
+        red_send_data(channel, NULL);
+    }
+}
+
+static void display_channel_hold_item(void *item)
+{
+    ASSERT(item);
+    switch (((PipeItem *)item)->type) {
+    case PIPE_ITEM_TYPE_DRAW:
+    case PIPE_ITEM_TYPE_STREAM_CREATE:
+        CONTAINEROF(item, Drawable, pipe_item)->refs++;
+        break;
+    case PIPE_ITEM_TYPE_STREAM_CLIP:
+        ((StreamClipItem *)item)->refs++;
+        break;
+    case PIPE_ITEM_TYPE_UPGRADE:
+        ((UpgradeItem *)item)->refs++;
+        break;
+    case PIPE_ITEM_TYPE_IMAGE:
+        ((ImageItem *)item)->refs++;
+        break;
+    default:
+        PANIC("invalid item type");
+    }
+}
+
+static void display_channel_release_item(RedChannel *channel, void *item)
+{
+    ASSERT(item);
+    switch (((PipeItem *)item)->type) {
+    case PIPE_ITEM_TYPE_DRAW:
+    case PIPE_ITEM_TYPE_STREAM_CREATE:
+        release_drawable(channel->worker, CONTAINEROF(item, Drawable, pipe_item));
+        break;
+    case PIPE_ITEM_TYPE_STREAM_CLIP:
+        red_display_release_stream_clip((DisplayChannel *)channel, (StreamClipItem *)item);
+        break;
+    case PIPE_ITEM_TYPE_UPGRADE:
+        release_upgrade_item(channel->worker, (UpgradeItem *)item);
+        break;
+    case PIPE_ITEM_TYPE_IMAGE:
+        release_image_item((ImageItem *)item);
+        break;
+    default:
+        PANIC("invalid item type");
+    }
+}
+
+static void handle_new_display_channel(RedWorker *worker, RedsStreamContext *peer, int migrate)
+{
+    DisplayChannel *display_channel;
+    size_t stream_buf_size;
+
+    red_disconnect_display((RedChannel *)worker->display_channel);
+
+    if (!(display_channel = (DisplayChannel *)__new_channel(worker, sizeof(*display_channel), peer,
+                                                            migrate, handle_channel_events,
+                                                            red_disconnect_display,
+                                                            display_channel_hold_item,
+                                                            display_channel_release_item,
+                                                            display_channel_handle_message))) {
+        return;
+    }
+#ifdef RED_STATISTICS
+    display_channel->stat = stat_add_node(worker->stat, "display_channel", TRUE);
+    display_channel->base.out_bytes_counter = stat_add_counter(display_channel->stat,
+                                                               "out_bytes", TRUE);
+    display_channel->cache_hits_counter = stat_add_counter(display_channel->stat,
+                                                           "cache_hits", TRUE);
+    display_channel->add_to_cache_counter = stat_add_counter(display_channel->stat,
+                                                             "add_to_cache", TRUE);
+    display_channel->non_cache_counter = stat_add_counter(display_channel->stat,
+                                                          "non_cache", TRUE);
+#endif
+    ring_init(&display_channel->palette_cache_lru);
+    display_channel->palette_cache_available = CLIENT_PALETTE_CACHE_SIZE;
+    red_display_init_streams(display_channel);
+
+    stream_buf_size = FF_MIN_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;
+    if (!(display_channel->send_data.stream_outbuf = malloc(stream_buf_size))) {
+        PANIC("alloc failed");
+    }
+    display_channel->send_data.stream_outbuf_size = FF_MIN_BUFFER_SIZE;
+    red_display_share_stream_buf(display_channel);
+    red_display_init_glz_data(display_channel);
+    worker->display_channel = display_channel;
+
+
+    if (!(display_channel->send_data.free_list.res = malloc(sizeof(RedResorceList) +
+                                                            DISPLAY_FREE_LIST_DEFAULT_SIZE *
+                                                            sizeof(RedResorceID)))) {
+        PANIC("free list alloc failed");
+    }
+    display_channel->send_data.free_list.res_size = DISPLAY_FREE_LIST_DEFAULT_SIZE;
+    red_ref_channel((RedChannel*)display_channel);
+    on_new_display_channel(worker);
+    red_unref_channel((RedChannel*)display_channel);
+
+    stat_compress_init(&display_channel->lz_stat, lz_stat_name);
+    stat_compress_init(&display_channel->glz_stat, glz_stat_name);
+    stat_compress_init(&display_channel->quic_stat, quic_stat_name);
+}
+
+static void red_disconnect_cursor(RedChannel *channel)
+{
+    if (!channel || !channel->peer) {
+        return;
+    }
+
+    ASSERT(channel == (RedChannel *)channel->worker->cursor_channel);
+    channel->worker->cursor_channel = NULL;
+    red_reset_cursor_cache((CursorChannel *)channel);
+    red_disconnect_channel(channel);
+}
+
+static void red_migrate_cursor(RedWorker *worker)
+{
+    if (worker->cursor_channel) {
+        red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+        red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_MIGRATE);
+    }
+}
+
+static void on_new_cursor_channel(RedWorker *worker)
+{
+    CursorChannel *channel = worker->cursor_channel;
+
+    ASSERT(channel);
+
+    channel->base.messages_window = 0;
+    red_pipe_add_type(&channel->base, PIPE_ITEM_TYPE_SET_ACK);
+    if (worker->attached && !channel->base.migrate) {
+        red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_CURSOR_INIT);
+    }
+}
+
+static void cursor_channel_hold_item(void *item)
+{
+    ASSERT(item);
+    ((CursorItem *)item)->refs++;
+}
+
+static void cursor_channel_release_item(RedChannel *channel, void *item)
+{
+    ASSERT(item);
+    red_release_cursor(channel->worker, item);
+}
+
+static void red_connect_cursor(RedWorker *worker, RedsStreamContext *peer, int migrate)
+{
+    CursorChannel *channel;
+
+    red_disconnect_cursor((RedChannel *)worker->cursor_channel);
+
+    if (!(channel = (CursorChannel *)__new_channel(worker, sizeof(*channel), peer, migrate,
+                                                   handle_channel_events,
+                                                   red_disconnect_cursor,
+                                                   cursor_channel_hold_item,
+                                                   cursor_channel_release_item,
+                                                   channel_handle_message))) {
+        return;
+    }
+#ifdef RED_STATISTICS
+    channel->stat = stat_add_node(worker->stat, "cursor_channel", TRUE);
+    channel->base.out_bytes_counter = stat_add_counter(channel->stat, "out_bytes", TRUE);
+#endif
+    ring_init(&channel->cursor_cache_lru);
+    channel->cursor_cache_available = CLIENT_CURSOR_CACHE_SIZE;
+    worker->cursor_channel = channel;
+    on_new_cursor_channel(worker);
+}
+
+typedef struct __attribute__ ((__packed__)) CursorData {
+    uint32_t visible;
+    Point16 position;
+    uint16_t trail_length;
+    uint16_t trail_frequency;
+    uint32_t data_size;
+    RedCursor _cursor;
+} CursorData;
+
+static void red_save_cursor(RedWorker *worker)
+{
+    CursorData *cursor_data;
+    LocalCursor *local;
+    int size;
+
+    ASSERT(worker->cursor);
+    ASSERT(worker->cursor->type == CURSOR_TYPE_LOCAL);
+
+    local = (LocalCursor *)worker->cursor;
+    size = sizeof(CursorData) + sizeof(RedCursor) + local->data_size;
+    cursor_data = malloc(size);
+    ASSERT(cursor_data);
+
+    cursor_data->position = worker->cursor_position;
+    cursor_data->visible = worker->cursor_visible;
+    cursor_data->trail_frequency = worker->cursor_trail_frequency;
+    cursor_data->trail_length = worker->cursor_trail_length;
+    cursor_data->data_size = local->data_size;
+    cursor_data->_cursor.header = local->red_cursor.header;
+    memcpy(cursor_data->_cursor.data, local->red_cursor.data, local->data_size);
+    worker->qxl->set_save_data(worker->qxl, cursor_data, size);
+}
+
+static LocalCursor *_new_local_cursor(CursorHeader *header, int data_size, Point16 position)
+{
+    LocalCursor *local;
+
+    local = (LocalCursor *)malloc(sizeof(LocalCursor) + data_size);
+    if (!local) {
+        return NULL;
+    }
+
+    red_pipe_item_init(&local->base.pipe_data, PIPE_ITEM_TYPE_LOCAL_CURSOR);
+    local->base.refs = 1;
+    local->base.type = CURSOR_TYPE_LOCAL;
+
+    local->red_cursor.header = *header;
+    local->red_cursor.header.unique = 0;
+    local->red_cursor.flags = 0;
+    local->position = position;
+    local->data_size = data_size;
+    return local;
+}
+
+static void red_cursor_flush(RedWorker *worker)
+{
+    QXLCursorCmd *cursor_cmd;
+    QXLCursor *qxl_cursor;
+    LocalCursor *local;
+    uint32_t data_size;
+    QXLDataChunk *chunk;
+    uint8_t *dest;
+
+    if (!worker->cursor || worker->cursor->type == CURSOR_TYPE_LOCAL) {
+        return;
+    }
+
+    ASSERT(worker->cursor->type == CURSOR_TYPE_DEV);
+
+    cursor_cmd = CONTAINEROF(worker->cursor, QXLCursorCmd, device_data);
+    ASSERT(cursor_cmd->type == QXL_CURSOR_SET);
+    qxl_cursor = (QXLCursor *)(cursor_cmd->u.set.shape + worker->dev_info.phys_delta);
+
+    local = _new_local_cursor(&qxl_cursor->header, qxl_cursor->data_size,
+                              worker->cursor_position);
+    ASSERT(local);
+    data_size = local->data_size;
+    dest = local->red_cursor.data;
+    chunk = &qxl_cursor->chunk;
+
+    while (data_size) {
+        ASSERT(chunk);
+        ASSERT(chunk->data_size <= data_size);
+        memcpy(dest, chunk->data, chunk->data_size);
+        data_size -= chunk->data_size;
+        dest += chunk->data_size;
+        chunk = chunk->next_chunk ? (QXLDataChunk *)(chunk->next_chunk +
+                                                     worker->dev_info.phys_delta) : NULL;
+    }
+    red_set_cursor(worker, &local->base);
+    red_release_cursor(worker, &local->base);
+}
+
+static void red_save(RedWorker *worker)
+{
+    if (!worker->cursor) {
+        worker->qxl->set_save_data(worker->qxl, NULL, 0);
+        return;
+    }
+    red_save_cursor(worker);
+}
+
+static void red_cursor_load(RedWorker *worker)
+{
+    CursorData *cursor_data = worker->qxl->get_save_data(worker->qxl);
+    LocalCursor *local;
+
+    if (!cursor_data) {
+        return;
+    }
+
+    worker->cursor_position = cursor_data->position;
+    worker->cursor_visible = cursor_data->visible;
+    worker->cursor_trail_frequency = cursor_data->trail_frequency;
+    worker->cursor_trail_length = cursor_data->trail_length;
+
+    local = _new_local_cursor(&cursor_data->_cursor.header, cursor_data->data_size,
+                              cursor_data->position);
+    ASSERT(local);
+    memcpy(local->red_cursor.data, cursor_data->_cursor.data, cursor_data->data_size);
+    red_set_cursor(worker, &local->base);
+    red_release_cursor(worker, &local->base);
+}
+
+static void red_wait_outgoiong_item(RedChannel *channel)
+{
+    uint64_t end_time;
+    int blocked;
+
+    if (!channel || !channel->send_data.blocked) {
+        return;
+    }
+    red_ref_channel(channel);
+
+    end_time = red_now() + DETACH_TIMEOUT;
+    red_printf("blocked");
+
+    do {
+        usleep(DETACH_SLEEP_DURATION);
+        red_receive(channel);
+        red_send_data(channel, NULL);
+    } while ((blocked = channel->send_data.blocked) && red_now() < end_time);
+
+    if (blocked) {
+        red_printf("timeout");
+        channel->disconnect(channel);
+    }
+    red_unref_channel(channel);
+}
+
+static inline void handle_dev_update(RedWorker *worker)
+{
+    RedWorkeMessage message;
+
+    ASSERT(worker->attached && worker->running);
+    for (;;) {
+        uint64_t end_time;
+
+        while (red_process_commands(worker, MAX_PIPE_SIZE)) {
+            display_channel_push(worker);
+        }
+
+        if (!worker->qxl->has_command(worker->qxl)) {
+            break;
+        }
+        end_time = red_now() + DISPLAY_CLIENT_TIMEOUT;
+        int sleep_count = 0;
+        for (;;) {
+            display_channel_push(worker);
+            if (!worker->display_channel ||
+                                         worker->display_channel->base.pipe_size <= MAX_PIPE_SIZE) {
+                break;
+            }
+            RedChannel *channel = (RedChannel *)worker->display_channel;
+            red_ref_channel(channel);
+            red_receive(channel);
+            red_send_data(channel, NULL);
+            if (red_now() >= end_time) {
+                red_printf("update timout");
+                red_disconnect_display((RedChannel *)worker->display_channel);
+            } else {
+                sleep_count++;
+                usleep(DISPLAY_CLIENT_RETRY_INTERVAL);
+            }
+            red_unref_channel(channel);
+        }
+    }
+    red_update_area(worker, worker->qxl->get_update_area(worker->qxl));
+    message = RED_WORKER_MESSAGE_READY;
+    write_message(worker->channel, &message);
+}
+
+static void handle_dev_input(EventListener *listener, uint32_t events)
+{
+    RedWorker *worker = CONTAINEROF(listener, RedWorker, dev_listener);
+    RedWorkeMessage message;
+
+    read_message(worker->channel, &message);
+
+    switch (message) {
+    case RED_WORKER_MESSAGE_UPDATE:
+        handle_dev_update(worker);
+        break;
+    case RED_WORKER_MESSAGE_WAKEUP:
+        clear_bit(RED_WORKER_PENDING_WAKEUP, worker->pending);
+        stat_inc_counter(worker->wakeup_counter, 1);
+        break;
+    case RED_WORKER_MESSAGE_OOM:
+        ASSERT(worker->attached && worker->running);
+        while (red_process_commands(worker, MAX_PIPE_SIZE)) {
+            display_channel_push(worker);
+        }
+        if (worker->qxl->flush_resources(worker->qxl) == 0) {
+            red_printf("oom current %u pipe %u", worker->current_size, worker->display_channel ?
+                       worker->display_channel->base.pipe_size : 0);
+            red_free_some(worker);
+        }
+        clear_bit(RED_WORKER_PENDING_OOM, worker->pending);
+        break;
+    case RED_WORKER_MESSAGE_ATTACH:
+        ASSERT(!worker->attached);
+        red_printf("attach");
+        receive_data(worker->channel, &worker->dev_info, sizeof(QXLDevInfo));
+        worker->attached = TRUE;
+        worker->repoll_cmd_ring = worker->repoll_cursor_ring = 0;
+        red_create_draw_context(worker);
+        ASSERT(ring_is_empty(&worker->current));
+        if (worker->display_channel && !worker->display_channel->base.migrate) {
+            red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_MODE);
+            red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_MARK);
+            display_channel_push(worker);
+        }
+        if (worker->cursor_channel && !worker->cursor_channel->base.migrate) {
+            red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_CURSOR_INIT);
+        }
+        message = RED_WORKER_MESSAGE_READY;
+        write_message(worker->channel, &message);
+        break;
+    case RED_WORKER_MESSAGE_DETACH:
+        red_printf("detach");
+        red_display_clear_glz_drawables(worker->display_channel);
+        red_current_clear(worker);
+#ifdef STREAM_TRACE
+        red_reset_stream_trace(worker);
+#endif
+        if (worker->cursor) {
+            red_release_cursor(worker, worker->cursor);
+            worker->cursor = NULL;
+        }
+
+        red_wait_outgoiong_item((RedChannel *)worker->cursor_channel);
+        if (worker->cursor_channel) {
+            red_pipe_add_type(&worker->cursor_channel->base, PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
+            if (!worker->cursor_channel->base.migrate) {
+                red_pipe_add_verb(&worker->cursor_channel->base, RED_CURSOR_RESET);
+            }
+            ASSERT(!worker->cursor_channel->base.send_data.item);
+        }
+
+        red_wait_outgoiong_item((RedChannel *)worker->display_channel);
+        ASSERT(ring_is_empty(&worker->streams));
+        if (worker->display_channel) {
+            red_pipe_add_type(&worker->display_channel->base, PIPE_ITEM_TYPE_INVAL_PALLET_CACHE);
+            red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_STREAM_DESTROY_ALL);
+            if (!worker->display_channel->base.migrate) {
+                red_pipe_add_verb(&worker->display_channel->base, RED_DISPLAY_RESET);
+            }
+            ASSERT(!worker->display_channel->base.send_data.item);
+        }
+
+        worker->attached = FALSE;
+        worker->cursor_visible = TRUE;
+        worker->cursor_position.x = worker->cursor_position.y = 0;
+        worker->cursor_trail_length = worker->cursor_trail_frequency = 0;
+
+        image_cache_reset(&worker->image_cache);
+        message = RED_WORKER_MESSAGE_READY;
+        write_message(worker->channel, &message);
+        break;
+    case RED_WORKER_MESSAGE_DISPLAY_CONNECT: {
+        RedsStreamContext *peer;
+        int migrate;
+        red_printf("connect");
+
+        receive_data(worker->channel, &peer, sizeof(RedsStreamContext *));
+        receive_data(worker->channel, &migrate, sizeof(int));
+        handle_new_display_channel(worker, peer, migrate);
+        break;
+    }
+    case RED_WORKER_MESSAGE_DISPLAY_DISCONNECT:
+        red_printf("disconnect");
+        red_disconnect_display((RedChannel *)worker->display_channel);
+        break;
+    case RED_WORKER_MESSAGE_SAVE:
+        red_printf("save");
+        ASSERT(!worker->running);
+        red_save(worker);
+        message = RED_WORKER_MESSAGE_READY;
+        write_message(worker->channel, &message);
+        break;
+    case RED_WORKER_MESSAGE_LOAD:
+        red_printf("load");
+        ASSERT(!worker->running);
+        red_add_screen_image(worker);
+        red_cursor_load(worker);
+        message = RED_WORKER_MESSAGE_READY;
+        write_message(worker->channel, &message);
+        break;
+    case RED_WORKER_MESSAGE_STOP: {
+        red_printf("stop");
+        ASSERT(worker->running);
+        worker->running = FALSE;
+        red_display_clear_glz_drawables(worker->display_channel);
+        red_current_flush(worker);
+        red_cursor_flush(worker);
+        red_wait_outgoiong_item((RedChannel *)worker->display_channel);
+        red_wait_outgoiong_item((RedChannel *)worker->cursor_channel);
+        message = RED_WORKER_MESSAGE_READY;
+        write_message(worker->channel, &message);
+        break;
+    }
+    case RED_WORKER_MESSAGE_START:
+        red_printf("start");
+        ASSERT(!worker->running);
+        if (worker->cursor_channel) {
+            worker->cursor_channel->base.migrate = FALSE;
+        }
+        if (worker->display_channel) {
+            worker->display_channel->base.migrate = FALSE;
+        }
+        worker->running = TRUE;
+        break;
+    case RED_WORKER_MESSAGE_DISPLAY_MIGRATE:
+        red_printf("migrate");
+        red_migrate_display(worker);
+        break;
+    case RED_WORKER_MESSAGE_CURSOR_CONNECT: {
+        RedsStreamContext *peer;
+        int migrate;
+
+        red_printf("cursor connect");
+        receive_data(worker->channel, &peer, sizeof(RedsStreamContext *));
+        receive_data(worker->channel, &migrate, sizeof(int));
+        red_connect_cursor(worker, peer, migrate);
+        break;
+    }
+    case RED_WORKER_MESSAGE_CURSOR_DISCONNECT:
+        red_printf("cursor disconnect");
+        red_disconnect_cursor((RedChannel *)worker->cursor_channel);
+        break;
+    case RED_WORKER_MESSAGE_CURSOR_MIGRATE:
+        red_printf("cursor migrate");
+        red_migrate_cursor(worker);
+        break;
+    case RED_WORKER_MESSAGE_SET_COMPRESSION:
+        receive_data(worker->channel, &worker->image_compression, sizeof(image_compression_t));
+        switch (worker->image_compression) {
+        case IMAGE_COMPRESS_AUTO_LZ:
+            red_printf("ic auto_lz");
+            break;
+        case IMAGE_COMPRESS_AUTO_GLZ:
+            red_printf("ic auto_glz");
+            break;
+        case IMAGE_COMPRESS_QUIC:
+            red_printf("ic quic");
+            break;
+        case IMAGE_COMPRESS_LZ:
+            red_printf("ic lz");
+            break;
+        case IMAGE_COMPRESS_GLZ:
+            red_printf("ic glz");
+            break;
+        case IMAGE_COMPRESS_OFF:
+            red_printf("ic off");
+            break;
+        default:
+            red_printf("ic invalid");
+        }
+#ifdef COMPRESS_STAT
+        print_compress_stats(worker->display_channel);
+        if (worker->display_channel) {
+            stat_reset(&worker->display_channel->quic_stat);
+            stat_reset(&worker->display_channel->lz_stat);
+            stat_reset(&worker->display_channel->glz_stat);
+        }
+#endif
+        break;
+    case RED_WORKER_MESSAGE_SET_STREAMING_VIDEO:
+        receive_data(worker->channel, &worker->streaming_video, sizeof(uint32_t));
+        red_printf("sv %u", worker->streaming_video);
+        break;
+    case RED_WORKER_MESSAGE_SET_MOUSE_MODE:
+        receive_data(worker->channel, &worker->mouse_mode, sizeof(uint32_t));
+        red_printf("mouse mode %u", worker->mouse_mode);
+        break;
+    default:
+        red_error("message error");
+    }
+}
+
+static void default_draw_context_destroy(void *canvas)
+{
+}
+
+static void red_init(RedWorker *worker, WorkerInitData *init_data)
+{
+    struct epoll_event event;
+    RedWorkeMessage message;
+    int epoll;
+
+    ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
+
+    memset(worker, 0, sizeof(RedWorker));
+    worker->qxl = init_data->qxl_interface;
+    worker->id = init_data->id;
+    worker->channel = init_data->channel;
+    worker->pending = init_data->pending;
+    worker->dev_listener.refs = 1;
+    worker->dev_listener.action = handle_dev_input;
+    worker->cursor_visible = TRUE;
+    worker->draw_context.destroy = default_draw_context_destroy;
+    ASSERT(init_data->num_renderers > 0);
+    worker->num_renderers = init_data->num_renderers;
+    memcpy(worker->renderers, init_data->renderers, sizeof(worker->renderers));
+    worker->mouse_mode = RED_MOUSE_MODE_SERVER;
+    worker->image_compression = init_data->image_compression;
+    worker->streaming_video = init_data->streaming_video;
+    ring_init(&worker->current_list);
+    ring_init(&worker->current);
+    image_cache_init(&worker->image_cache);
+    drawables_init(worker);
+    red_init_streams(worker);
+    stat_init(&worker->add_stat, add_stat_name);
+    stat_init(&worker->exclude_stat, exclude_stat_name);
+    stat_init(&worker->__exclude_stat, __exclude_stat_name);
+#ifdef RED_STATISTICS
+    char worker_str[20];
+    sprintf(worker_str, "display[%d]", worker->id);
+    worker->stat = stat_add_node(INVALID_STAT_REF, worker_str, TRUE);
+    worker->wakeup_counter = stat_add_counter(worker->stat, "wakeups", TRUE);
+    worker->command_counter = stat_add_counter(worker->stat, "commands", TRUE);
+#endif
+    if ((epoll = epoll_create(MAX_EPOLL_SOURCES)) == -1) {
+        red_error("epoll_create failed, %s", strerror(errno));
+    }
+    worker->epoll = epoll;
+
+    event.events = EPOLLIN;
+    event.data.ptr = &worker->dev_listener;
+
+    if (epoll_ctl(epoll, EPOLL_CTL_ADD, worker->channel, &event) == -1) {
+        red_error("add channel failed, %s", strerror(errno));
+    }
+
+    message = RED_WORKER_MESSAGE_READY;
+    write_message(worker->channel, &message);
+}
+
+void *red_worker_main(void *arg)
+{
+    RedWorker worker;
+
+    red_printf("begin");
+    ASSERT(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
+           MAX_PIPE_SIZE > NARROW_CLIENT_ACK_WINDOW); //ensure wakeup by ack message
+    ASSERT(QXL_BITMAP_TOP_DOWN == BITMAP_TOP_DOWN);
+
+#if  defined(RED_WORKER_STAT) || defined(COMPRESS_STAT)
+    if (pthread_getcpuclockid(pthread_self(), &clock_id)) {
+        red_error("pthread_getcpuclockid failed");
+    }
+#endif
+
+    avcodec_init();
+    avcodec_register_all();
+    red_init(&worker, (WorkerInitData *)arg);
+    red_init_quic(&worker);
+    red_init_lz(&worker);
+    worker.epoll_timeout = INF_EPOLL_WAIT;
+    for (;;) {
+        struct epoll_event events[MAX_EPOLL_SOURCES];
+        int num_events;
+        struct epoll_event *event;
+        struct epoll_event *end;
+
+        worker.epoll_timeout = MIN(red_get_streams_timout(&worker), worker.epoll_timeout);
+        num_events = epoll_wait(worker.epoll, events, MAX_EPOLL_SOURCES, worker.epoll_timeout);
+        red_handle_streams_timout(&worker);
+        if (worker.display_channel && worker.display_channel->glz_dict) {
+            /* during migration, in the dest, the display channel can be initialized
+               while the global lz data not since migrate data msg hasn't been
+               recieved yet */
+            red_display_handle_glz_drawables_to_free(worker.display_channel);
+        }
+        worker.epoll_timeout = INF_EPOLL_WAIT;
+        if (num_events == -1) {
+            if (errno != EINTR) {
+                red_error("poll_wait failed, %s", strerror(errno));
+            }
+            num_events = 0;
+        }
+
+        for (event = events, end = event + num_events;  event < end; event++) {
+            EventListener *evt_listener = (EventListener *)event->data.ptr;
+            evt_listener->refs++;
+        }
+
+        for (event = events, end = event + num_events; event < end; event++) {
+            EventListener *evt_listener = (EventListener *)event->data.ptr;
+
+            if (evt_listener->refs > 1) {
+                evt_listener->action(evt_listener, event->events);
+                if (--evt_listener->refs) {
+                    continue;
+                }
+            }
+            free(evt_listener);
+        }
+
+        if (worker.attached && worker.running) {
+            red_process_cursor(&worker, MAX_PIPE_SIZE);
+            red_process_commands(&worker, MAX_PIPE_SIZE);
+        }
+        red_push(&worker);
+    }
+    red_printf("exit");
+    return 0;
+}
+
+#ifdef DUMP_BITMAP
+#include <stdio.h>
+static void dump_palette(FILE *f, Palette* plt)
+{
+    int i;
+    for (i = 0; i < plt->num_ents; i++) {
+        fwrite(plt->ents + i, sizeof(uint32_t), 1, f);
+    }
+}
+
+static void dump_line(FILE *f, uint8_t* line, uint16_t n_pixel_bits, int width, int row_size)
+{
+    int i;
+    int copy_bytes_size = ALIGN(n_pixel_bits * width, 8) / 8;
+
+    fwrite(line, 1, copy_bytes_size, f);
+    if (row_size > copy_bytes_size) {
+        // each line should be 4 bytes aligned
+        for (i = copy_bytes_size; i < row_size; i++) {
+            fprintf(f, "%c", 0);
+        }
+    }
+}
+
+#define RAM_PATH "/tmp/tmpfs"
+
+static void dump_bitmap(RedWorker *worker, Bitmap *bitmap)
+{
+    static uint32_t file_id = 0;
+
+    char file_str[200];
+    int rgb = TRUE;
+    uint16_t n_pixel_bits;
+    Palette *plt = NULL;
+    uint32_t id;
+    int row_size;
+    uint32_t file_size;
+    long address_delta = worker->dev_info.phys_delta;
+    int alpha = 0;
+    uint32_t header_size = 14 + 40;
+    uint32_t bitmap_data_offset;
+    uint32_t tmp_u32;
+    int32_t tmp_32;
+    uint16_t tmp_u16;
+    FILE *f;
+
+    switch (bitmap->format) {
+    case BITMAP_FMT_1BIT_BE:
+    case BITMAP_FMT_1BIT_LE:
+        rgb = FALSE;
+        n_pixel_bits = 1;
+        break;
+    case BITMAP_FMT_4BIT_BE:
+    case BITMAP_FMT_4BIT_LE:
+        rgb = FALSE;
+        n_pixel_bits = 4;
+        break;
+    case BITMAP_FMT_8BIT:
+        rgb = FALSE;
+        n_pixel_bits = 8;
+        break;
+    case BITMAP_FMT_16BIT:
+        n_pixel_bits = 16;
+        break;
+    case BITMAP_FMT_24BIT:
+        n_pixel_bits = 24;
+        break;
+    case BITMAP_FMT_32BIT:
+        n_pixel_bits = 32;
+        break;
+    case BITMAP_FMT_RGBA:
+        n_pixel_bits = 32;
+        alpha = 1;
+        break;
+    default:
+        red_error("invalid bitmap format  %u", bitmap->format);
+    }
+
+    if (!rgb) {
+        if (!bitmap->palette) {
+            return; // dont dump masks.
+        }
+        plt = (Palette *)(bitmap->palette + address_delta);
+    }
+    row_size = (((bitmap->x * n_pixel_bits) + 31) / 32) * 4;
+    bitmap_data_offset = header_size;
+
+    if (plt) {
+        bitmap_data_offset += plt->num_ents * 4;
+    }
+    file_size = bitmap_data_offset + (bitmap->y * row_size);
+
+    id = ++file_id;
+    sprintf(file_str, "%s/%u.bmp", RAM_PATH, id);
+
+    f = fopen(file_str, "wb");
+    if (!f) {
+        red_error("Error creating bmp\n");
+        return;
+    }
+
+    /* writing the bmp v3 header */
+    fprintf(f, "BM");
+    fwrite(&file_size, sizeof(file_size), 1, f);
+    tmp_u16 = alpha ? 1 : 0;
+    fwrite(&tmp_u16, sizeof(tmp_u16), 1, f); // reserved for application
+    tmp_u16 = 0;
+    fwrite(&tmp_u16, sizeof(tmp_u16), 1, f);
+    fwrite(&bitmap_data_offset, sizeof(bitmap_data_offset), 1, f);
+    tmp_u32 = header_size - 14;
+    fwrite(&tmp_u32, sizeof(tmp_u32), 1, f); // sub header size
+    tmp_32 = bitmap->x;
+    fwrite(&tmp_32, sizeof(tmp_32), 1, f);
+    tmp_32 = bitmap->y;
+    fwrite(&tmp_32, sizeof(tmp_32), 1, f);
+
+    tmp_u16 = 1;
+    fwrite(&tmp_u16, sizeof(tmp_u16), 1, f); // color plane
+    fwrite(&n_pixel_bits, sizeof(n_pixel_bits), 1, f); // pixel depth
+
+    tmp_u32 = 0;
+    fwrite(&tmp_u32, sizeof(tmp_u32), 1, f); // compression method
+
+    tmp_u32 = 0; //file_size - bitmap_data_offset;
+    fwrite(&tmp_u32, sizeof(tmp_u32), 1, f); // image size
+    tmp_32 = 0;
+    fwrite(&tmp_32, sizeof(tmp_32), 1, f);
+    fwrite(&tmp_32, sizeof(tmp_32), 1, f);
+    tmp_u32 = (!plt) ? 0 : plt->num_ents; // plt entries
+    fwrite(&tmp_u32, sizeof(tmp_u32), 1, f);
+    tmp_u32 = 0;
+    fwrite(&tmp_u32, sizeof(tmp_u32), 1, f);
+
+    if (plt) {
+        dump_palette(f, plt);
+    }
+    /* writing the data */
+    if ((bitmap->flags & QXL_BITMAP_DIRECT)) {
+        uint8_t *lines = (uint8_t*)(bitmap->data + address_delta);
+        int i;
+        for (i = 0; i < bitmap->y; i++) {
+            dump_line(f, lines + (i * bitmap->stride), n_pixel_bits, bitmap->x, row_size);
+        }
+    } else {
+        QXLDataChunk *chunk = NULL;
+        int num_lines;
+        ADDRESS relative_address = bitmap->data;
+
+        while (relative_address) {
+            int i;
+            chunk = (QXLDataChunk *)(relative_address + address_delta);
+            num_lines = chunk->data_size / bitmap->stride;
+            for (i = 0; i < num_lines; i++) {
+                dump_line(f, chunk->data + (i * bitmap->stride), n_pixel_bits, bitmap->x, row_size);
+            }
+            relative_address = chunk->next_chunk;
+        }
+    }
+    fclose(f);
+}
+
+#endif
+
diff --git a/server/red_worker.h b/server/red_worker.h
new file mode 100644
index 00000000..097d4540
--- /dev/null
+++ b/server/red_worker.h
@@ -0,0 +1,134 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REDWORKER
+#define _H_REDWORKER
+
+#include "red_common.h"
+
+
+static inline void set_bit(int index, uint32_t *addr)
+{
+    __asm__ __volatile__ ("lock btsl %1, %0": : "m" (*addr), "r" (index));
+}
+
+static inline void clear_bit(int index, uint32_t *addr)
+{
+    __asm__ __volatile__ ("lock btrl %1, %0": : "m" (*addr), "r" (index));
+}
+
+static inline int test_bit(int index, uint32_t val)
+{
+    return val & (1u << index);
+}
+
+enum {
+    RED_WORKER_PENDING_WAKEUP,
+    RED_WORKER_PENDING_OOM,
+};
+
+enum {
+    RED_WORKER_MESSAGE_NOP,
+    RED_WORKER_MESSAGE_UPDATE,
+    RED_WORKER_MESSAGE_WAKEUP,
+    RED_WORKER_MESSAGE_OOM,
+    RED_WORKER_MESSAGE_ATTACH,
+    RED_WORKER_MESSAGE_DETACH,
+    RED_WORKER_MESSAGE_READY,
+    RED_WORKER_MESSAGE_DISPLAY_CONNECT,
+    RED_WORKER_MESSAGE_DISPLAY_DISCONNECT,
+    RED_WORKER_MESSAGE_DISPLAY_MIGRATE,
+    RED_WORKER_MESSAGE_SAVE,
+    RED_WORKER_MESSAGE_LOAD,
+    RED_WORKER_MESSAGE_START,
+    RED_WORKER_MESSAGE_STOP,
+    RED_WORKER_MESSAGE_CURSOR_CONNECT,
+    RED_WORKER_MESSAGE_CURSOR_DISCONNECT,
+    RED_WORKER_MESSAGE_CURSOR_MIGRATE,
+    RED_WORKER_MESSAGE_SET_COMPRESSION,
+    RED_WORKER_MESSAGE_SET_STREAMING_VIDEO,
+    RED_WORKER_MESSAGE_SET_MOUSE_MODE,
+};
+
+typedef uint32_t RedWorkeMessage;
+
+#define RED_MAX_RENDERERS 4
+
+enum {
+    RED_RENDERER_INVALID,
+    RED_RENDERER_CAIRO,
+    RED_RENDERER_OGL_PBUF,
+    RED_RENDERER_OGL_PIXMAP,
+};
+
+typedef struct WorkerInitData {
+    struct QXLInterface *qxl_interface;
+    int id;
+    int channel;
+    uint32_t *pending;
+    uint32_t num_renderers;
+    uint32_t renderers[RED_MAX_RENDERERS];
+    image_compression_t image_compression;
+    int streaming_video;
+} WorkerInitData;
+
+void *red_worker_main(void *arg);
+
+static inline void send_data(int fd, void *in_buf, int n)
+{
+    uint8_t *buf = in_buf;
+    do {
+        int now;
+        if ((now = write(fd, buf, n)) == -1) {
+            if (errno == EINTR) {
+                continue;
+            }
+            red_error("%s", strerror(errno));
+        }
+        buf += now;
+        n -= now;
+    } while (n);
+}
+
+static inline void write_message(int fd, RedWorkeMessage *message)
+{
+    send_data(fd, message, sizeof(RedWorkeMessage));
+}
+
+static inline void receive_data(int fd, void *in_buf, int n)
+{
+    uint8_t *buf = in_buf;
+    do {
+        int now;
+        if ((now = read(fd, buf, n)) == -1) {
+            if (errno == EINTR) {
+                continue;
+            }
+            red_error("%s", strerror(errno));
+        }
+        buf += now;
+        n -= now;
+    } while (n);
+}
+
+static inline void read_message(int fd, RedWorkeMessage *message)
+{
+    receive_data(fd, message, sizeof(RedWorkeMessage));
+}
+
+#endif
+
diff --git a/server/red_yuv.h b/server/red_yuv.h
new file mode 100644
index 00000000..9a2242cc
--- /dev/null
+++ b/server/red_yuv.h
@@ -0,0 +1,154 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#if defined(YUV32)
+#define PIXEL_SIZE 4
+#define R(pixel) (((uint8_t*)(pixel))[0])
+#define G(pixel) (((uint8_t*)(pixel))[1])
+#define B(pixel) (((uint8_t*)(pixel))[2])
+
+#define FUNC_NAME(name) name##_32bpp
+
+#elif defined(YUV24)
+#define PIXEL_SIZE 3
+#define R(pixel) (((uint8_t*)(pixel))[0])
+#define G(pixel) (((uint8_t*)(pixel))[1])
+#define B(pixel) (((uint8_t*)(pixel))[2])
+
+#define FUNC_NAME(name) name##_24bpp
+
+#elif defined(YUV16)
+#define PIXEL_SIZE 2
+#define PIX16(pixel) (*(uint16_t*)(pixel))
+
+#define R(pixel) ((PIX16(pixel) << 3) & 0xff)
+#define G(pixel) ((PIX16(pixel) >> 2) & 0xff)
+#define B(pixel) ((PIX16(pixel) >> 7) & 0xff)
+
+#define FUNC_NAME(name) name##_16bpp
+
+#else
+#error "invalid format."
+#endif
+
+#define Y(pixel) (((66 * R(pixel) + 129 * G(pixel) + 25 * B(pixel) + 128) >> 8) + 16)
+#define U(pixel) (((-38 * R(pixel) - 74 * G(pixel) + 112 * B(pixel) + 128) >> 8) + 128)
+#define V(pixel) (((112 * R(pixel) - 94 * G(pixel) - 18 * B(pixel) + 128) >> 8) + 128)
+
+static inline void FUNC_NAME(red_rgb_to_yuv420_line)(const uint8_t* line0, const uint8_t* line1,
+                                                     const uint32_t width, uint8_t* y, uint8_t *u,
+                                                     uint8_t *v, int y_stride)
+{
+    int i;
+
+    // Y = (0.257 * R) + (0.504 * G) + (0.098 * B) + 16
+    // Cb = U = -(0.148 * R) - (0.291 * G) + (0.439 * B) + 128
+    // Cr = V = (0.439 * R) - (0.368 * G) - (0.071 * B) + 128
+
+    for (i = 0; i < width / 2; i++) {
+        *y = Y(line0);
+        *(y + 1) = Y(line0 + PIXEL_SIZE);
+        *(y + y_stride) = Y(line1);
+        *(y + y_stride + 1) = Y(line1 + PIXEL_SIZE);
+
+        u[i] = (U(line0) + U(line0 + PIXEL_SIZE) + U(line1) + U(line1 + PIXEL_SIZE)) / 4;
+        v[i] = (V(line0) + V(line0 + PIXEL_SIZE) + V(line1) + V(line1 + PIXEL_SIZE)) / 4;
+
+        line0 += 2 * PIXEL_SIZE;
+        line1 += 2 * PIXEL_SIZE;
+        y += 2;
+    }
+
+    if ((width & 1)) {
+        *y = Y(line0);
+        *(y + 1) = *y;
+        *(y + y_stride) = Y(line1);
+        *(y + y_stride + 1) = *(y + y_stride);
+        u[i] = (U(line0) + U(line1)) / 2;
+        v[i] = (V(line0) + V(line1)) / 2;
+    }
+}
+
+static inline int FUNC_NAME(red_rgb_to_yuv420)(const Rect *src, const Bitmap *image,
+                                               AVFrame *frame, long phys_delta, int id,
+                                               Stream *stream)
+{
+    QXLDataChunk *chunk;
+    uint32_t image_stride;
+    int y_stride;
+    uint8_t* y;
+    uint8_t* u;
+    uint8_t* v;
+    int offset;
+    int i;
+
+    y = frame->data[0];
+    u = frame->data[1];
+    v = frame->data[2];
+    y_stride = frame->linesize[0];
+
+    offset = 0;
+    chunk = (QXLDataChunk *)(image->data + phys_delta);
+    image_stride = image->stride;
+
+    const int skip_lines = stream->top_down ? src->top : image->y - (src->bottom - 0);
+    for (i = 0; i < skip_lines; i++) {
+        red_get_image_line(&chunk, &offset, image_stride, phys_delta);
+    }
+
+    const int image_hight = src->bottom - src->top;
+    const int image_width = src->right - src->left;
+    for (i = 0; i < image_hight / 2; i++) {
+        uint8_t* line0 = red_get_image_line(&chunk, &offset, image_stride, phys_delta);
+        uint8_t* line1 = red_get_image_line(&chunk, &offset, image_stride, phys_delta);
+
+        if (!line0 || !line1) {
+            return FALSE;
+        }
+
+        line0 += src->left * PIXEL_SIZE;
+        line1 += src->left * PIXEL_SIZE;
+
+        FUNC_NAME(red_rgb_to_yuv420_line)(line0, line1, image_width, y, u, v, y_stride);
+
+        y += 2 * y_stride;
+        u += frame->linesize[1];
+        v += frame->linesize[2];
+    }
+
+    if ((image_hight & 1)) {
+        uint8_t* line = red_get_image_line(&chunk, &offset, image_stride, phys_delta);
+        if (!line) {
+            return FALSE;
+        }
+        line += src->left * PIXEL_SIZE;
+        FUNC_NAME(red_rgb_to_yuv420_line)(line, line, image_width, y, u, v, y_stride);
+    }
+    return TRUE;
+}
+
+
+#undef R
+#undef G
+#undef B
+#undef Y
+#undef U
+#undef V
+#undef FUNC_NAME
+#undef PIXEL_SIZE
+#undef PIX16
+
diff --git a/server/reds.c b/server/reds.c
new file mode 100644
index 00000000..067304d7
--- /dev/null
+++ b/server/reds.c
@@ -0,0 +1,4996 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <limits.h>
+#include <time.h>
+#include <pthread.h>
+#include <sys/mman.h>
+#include <sys/user.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include <openssl/bio.h>
+#include <openssl/pem.h>
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include "spice.h"
+#include "reds.h"
+#include "red.h"
+#include "vd_agent.h"
+
+#include "red_common.h"
+#include "red_dispatcher.h"
+#include "snd_worker.h"
+#include "reds_stat.h"
+#include "stat.h"
+#include "ring.h"
+#include "config.h"
+
+CoreInterface *core = NULL;
+static MigrationInterface *mig = NULL;
+static KeyboardInterface *keyboard = NULL;
+static MouseInterface *mouse = NULL;
+static TabletInterface *tablet = NULL;
+static VDIPortInterface *vdagent = NULL;
+
+#define MIGRATION_NOTIFY_SPICE_KEY "spice_mig_ext"
+
+#define REDS_MIG_VERSION 1
+#define REDS_MIG_CONTINUE 1
+#define REDS_MIG_ABORT 2
+
+#define REDS_AGENT_WINDOW_SIZE 10
+#define REDS_TOKENS_TO_SEND 5
+#define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
+#define REDS_VDI_PORT_NUM_RECIVE_BUFFS 5
+#define REDS_MAX_SEND_IOVEC 100
+
+#define NET_TEST_WARMUP_BYTES 0
+#define NET_TEST_BYTES (1024 * 250)
+
+static int spice_port = -1;
+static int spice_secure_port = -1;
+
+static struct in_addr spice_addr = {INADDR_ANY};
+static int ticketing_enabled = 1; //Ticketing is enabled by default
+static pthread_mutex_t *lock_cs;
+static long *lock_count;
+uint32_t streaming_video = TRUE;
+image_compression_t image_compression = IMAGE_COMPRESS_AUTO_GLZ;
+int agent_mouse = TRUE;
+
+static void openssl_init();
+
+#define MIGRATE_TIMEOUT (1000 * 10) /* 10sec */
+#define PING_INTERVAL (1000 * 10)
+#define KEY_MODIFIERS_TTL (1000 * 2) /*2sec*/
+#define MM_TIMER_GRANULARITY_MS (1000 / 30)
+#define MM_TIME_DELTA 400 /*ms*/
+
+// approximate max recive message size
+#define RECIVE_BUF_SIZE \
+    (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) * RED_AGENT_MAX_DATA_SIZE)
+
+#define SEND_BUF_SIZE 4096
+
+#define SCROLL_LOCK_SCAN_CODE 0x46
+#define NUM_LOCK_SCAN_CODE 0x45
+#define CAPS_LOCK_SCAN_CODE 0x3a
+
+typedef struct IncomingHandler {
+    void *opaque;
+    int shut;
+    uint8_t buf[RECIVE_BUF_SIZE];
+    uint32_t end_pos;
+    void (*handle_message)(void *opaque, RedDataHeader *message);
+} IncomingHandler;
+
+typedef struct OutgoingHandler {
+    void *opaque;
+    uint8_t buf[SEND_BUF_SIZE];
+    uint8_t *now;
+    uint32_t length;
+    void (*select)(void *opaque, int select);
+    void (*may_write)(void *opaque);
+} OutgoingHandler;
+
+typedef struct TicketAuthentication {
+    char password[RED_MAX_PASSWORD_LENGTH];
+    time_t expiration_time;
+} TicketAuthentication;
+
+static TicketAuthentication taTicket;
+
+typedef struct TicketInfo {
+    RSA *rsa;
+    int rsa_size;
+    BIGNUM *bn;
+    RedLinkEncryptedTicket encrypted_ticket;
+} TicketInfo;
+
+typedef struct MonitorMode {
+    uint32_t x_res;
+    uint32_t y_res;
+} MonitorMode;
+
+typedef struct RedsOutItem RedsOutItem;
+struct RedsOutItem {
+    RingItem link;
+    void (*prepare)(RedsOutItem *item, struct iovec* vec, int *len);
+    void (*release)(RedsOutItem *item);
+};
+
+typedef struct VDIReadBuf {
+    RedsOutItem out_item;
+    int len;
+    RedDataHeader header;
+    uint8_t data[RED_AGENT_MAX_DATA_SIZE];
+} VDIReadBuf;
+
+enum {
+    VDI_PORT_READ_STATE_READ_HADER,
+    VDI_PORT_READ_STATE_GET_BUFF,
+    VDI_PORT_READ_STATE_READ_DATA,
+};
+
+enum {
+    VDP_CLIENT_PORT = 1,
+    VDP_SERVER_PORT,
+};
+
+typedef struct __attribute__ ((__packed__)) VDIChunkHeader {
+    uint32_t port;
+    uint32_t size;
+} VDIChunkHeader;
+
+typedef struct VDIPortState {
+    VDIPortPlug plug;
+    VDObjectRef plug_ref;
+    uint32_t plug_generation;
+
+    uint32_t num_tokens;
+    uint32_t num_client_tokens;
+    Ring external_bufs;
+    Ring internal_bufs;
+    Ring write_queue;
+
+    Ring read_bufs;
+    uint32_t read_state;
+    uint32_t message_recive_len;
+    uint8_t *recive_pos;
+    uint32_t recive_len;
+    VDIReadBuf *current_read_buf;
+
+    VDIChunkHeader vdi_chunk_header;
+
+    int client_agent_started;
+    uint32_t send_tokens;
+} VDIPortState;
+
+typedef struct InputsState {
+    Channel *channel;
+    RedsStreamContext *peer;
+    uint8_t buf[RECIVE_BUF_SIZE];
+    uint32_t end_pos;
+    IncomingHandler in_handler;
+    OutgoingHandler out_handler;
+    VDAgentMouseState mouse_state;
+    int pending_mouse_event;
+    uint32_t motion_count;
+    uint64_t serial; //migrate me
+} InputsState;
+
+typedef struct RedsOutgoingData {
+    Ring pipe;
+    RedsOutItem *item;
+    int vec_size;
+    struct iovec vec_buf[REDS_MAX_SEND_IOVEC];
+    struct iovec *vec;
+} RedsOutgoingData;
+
+enum NetTestStage {
+    NET_TEST_STAGE_INVALID,
+    NET_TEST_STAGE_WARMUP,
+    NET_TEST_STAGE_LATENCY,
+    NET_TEST_STAGE_RATE,
+};
+
+#ifdef RED_STATISTICS
+
+#define REDS_MAX_STAT_NODES 100
+#define REDS_STAT_SHM_SIZE (sizeof(RedsStat) + REDS_MAX_STAT_NODES * sizeof(StatNode))
+
+typedef struct RedsStatValue {
+    uint32_t value;
+    uint32_t min;
+    uint32_t max;
+    uint32_t average;
+    uint32_t count;
+} RedsStatValue;
+
+#endif
+
+typedef struct RedsState {
+    int listen_socket;
+    int secure_listen_socket;
+    RedsStreamContext *peer;
+    int disconnecting;
+    uint32_t link_id;
+    uint64_t serial; //migrate me
+    VDIPortState agent_state;
+    InputsState *inputs_state;
+
+    VDObjectRef mig_notifier;
+    int mig_wait_connect;
+    int mig_wait_disconnect;
+    int mig_inprogress;
+    int mig_target;
+    int num_of_channels;
+    IncomingHandler in_handler;
+    RedsOutgoingData outgoing;
+    Channel *channels;
+    int mouse_mode;
+    int is_client_mouse_allowed;
+    int dispatcher_allows_client_mouse;
+    MonitorMode monitor_mode;
+    VDObjectRef mig_timer;
+    VDObjectRef key_modifiers_timer;
+    VDObjectRef mm_timer;
+
+    TicketAuthentication taTicket;
+    SSL_CTX *ctx;
+
+#ifdef RED_STATISTICS
+    char *stat_shm_name;
+    RedsStat *stat;
+    pthread_mutex_t stat_lock;
+    RedsStatValue roundtrip_stat;
+    VDObjectRef ping_timer;
+    int ping_interval;
+#endif
+    uint32_t ping_id;
+    uint32_t net_test_id;
+    int net_test_stage;
+} RedsState;
+
+uint64_t bitrate_per_sec = ~0;
+static uint64_t letancy = 0;
+
+static RedsState *reds = NULL;
+
+typedef struct AsyncRead {
+    RedsStreamContext *peer;
+    void *opaque;
+    uint8_t *now;
+    uint8_t *end;
+    int active_file_handlers;
+    void (*done)(void *opaque);
+    void (*error)(void *opaque, int err);
+} AsyncRead;
+
+typedef struct RedLinkInfo {
+    RedsStreamContext *peer;
+    AsyncRead asyc_read;
+    RedLinkHeader link_header;
+    RedLinkMess *link_mess;
+    int mess_pos;
+    TicketInfo tiTicketing;
+} RedLinkInfo;
+
+typedef struct VDIPortBuf VDIPortBuf;
+struct  __attribute__ ((__packed__)) VDIPortBuf {
+    RingItem link;
+    uint8_t *now;
+    int write_len;
+    void (*free)(VDIPortBuf *buf);
+    VDIChunkHeader chunk_header; //start send from &chunk_header
+};
+
+typedef struct __attribute__ ((__packed__)) VDAgentExtBuf {
+    VDIPortBuf base;
+    uint8_t buf[RED_AGENT_MAX_DATA_SIZE];
+    VDIChunkHeader migrate_overflow;
+} VDAgentExtBuf;
+
+typedef struct __attribute__ ((__packed__)) VDInternalBuf {
+    VDIPortBuf base;
+    VDAgentMessage header;
+    union {
+        VDAgentMouseState mouse_state;
+    }
+    u;
+    VDIChunkHeader migrate_overflow;
+} VDInternalBuf;
+
+typedef struct RedSSLParameters {
+    char keyfile_password[256];
+    char certs_file[256];
+    char private_key_file[256];
+    char ca_certificate_file[256];
+    char dh_key_file[256];
+    char ciphersuite[256];
+} RedSSLParameters;
+
+#define CHANNEL_SECURITY_NON (1 << 0)
+#define CHANNEL_SECURITY_SSL (1 << 1)
+
+typedef struct ChannelSecurityOptions ChannelSecurityOptions;
+struct ChannelSecurityOptions {
+    uint32_t channel_id;
+    uint32_t options;
+    ChannelSecurityOptions *next;
+};
+
+typedef struct PingItem {
+    RedsOutItem base;
+    RedDataHeader header;
+    RedPing ping;
+    int size;
+} PingItem;
+
+static uint8_t zero_page[PAGE_SIZE] = {0};
+
+static void reds_main_write(void *data);
+static void reds_push();
+
+static ChannelSecurityOptions *channels_security = NULL;
+static int default_channel_security = CHANNEL_SECURITY_NON | CHANNEL_SECURITY_SSL;
+
+static RedSSLParameters ssl_parameters;
+
+
+void (*log_proc)(CoreInterface *core, LogLevel level, const char* component,
+                 const char* format, ...) = NULL;
+
+#define LOG_MESSAGE(level, format, ...) {                           \
+    if (log_proc) {                                                 \
+        log_proc(core, level, "spice", format, ## __VA_ARGS__ );    \
+    }                                                               \
+}
+
+static ChannelSecurityOptions *find_channel_security(int id)
+{
+    ChannelSecurityOptions *now = channels_security;
+    while (now && now->channel_id != id) {
+        now = now->next;
+    }
+    return now;
+}
+
+static int reds_write(void *ctx, void *buf, size_t size)
+{
+    int return_code;
+    int sock = (long)ctx;
+    size_t count = size;
+
+    return_code = write(sock, buf, count);
+
+    return (return_code);
+}
+
+static int reds_read(void *ctx, void *buf, size_t size)
+{
+    int return_code;
+    int sock = (long)ctx;
+    size_t count = size;
+
+    return_code = read(sock, buf, count);
+
+    return (return_code);
+}
+
+static int reds_free(RedsStreamContext *peer)
+{
+    close(peer->socket);
+    free(peer);
+    return 0;
+}
+
+static int reds_ssl_write(void *ctx, void *buf, size_t size)
+{
+    int return_code;
+    int ssl_error;
+    SSL *ssl = ctx;
+
+    return_code = SSL_write(ssl, buf, size);
+
+    if (return_code < 0) {
+        ssl_error = SSL_get_error(ssl, return_code);
+    }
+
+    return (return_code);
+}
+
+static int reds_ssl_read(void *ctx, void *buf, size_t size)
+{
+    int return_code;
+    int ssl_error;
+    SSL *ssl = ctx;
+
+    return_code = SSL_read(ssl, buf, size);
+
+    if (return_code < 0) {
+        ssl_error = SSL_get_error(ssl, return_code);
+    }
+
+    return (return_code);
+}
+
+static int reds_ssl_writev(void *ctx, const struct iovec *vector, int count)
+{
+    int i;
+    int n;
+    int return_code = 0;
+    int ssl_error;
+    SSL *ssl = ctx;
+
+    for (i = 0; i < count; ++i) {
+        n = SSL_write(ssl, vector[i].iov_base, vector[i].iov_len);
+        if (n <= 0) {
+            ssl_error = SSL_get_error(ssl, n);
+            if (return_code <= 0) {
+                return n;
+            } else {
+                break;
+            }
+        } else {
+            return_code += n;
+        }
+    }
+
+    return return_code;
+}
+
+static int reds_ssl_free(RedsStreamContext *peer)
+{
+    SSL_free(peer->ssl);
+    close(peer->socket);
+    free(peer);
+    return 0;
+}
+
+static void __reds_release_link(RedLinkInfo *link)
+{
+    ASSERT(link->peer);
+    core->set_file_handlers(core, link->peer->socket, NULL, NULL, NULL);
+    free(link->link_mess);
+    BN_free(link->tiTicketing.bn);
+    if (link->tiTicketing.rsa) {
+        RSA_free(link->tiTicketing.rsa);
+    }
+    free(link);
+}
+
+static inline void reds_release_link(RedLinkInfo *link)
+{
+    RedsStreamContext *peer = link->peer;
+    __reds_release_link(link);
+    peer->cb_free(peer);
+}
+
+static void reds_do_disable_ticketing(void)
+{
+    ticketing_enabled = 0;
+    memset(taTicket.password, 0, sizeof(taTicket.password));
+    core->term_printf(core, "Ticketing is now disabled.\n");
+}
+
+static char *base64decode(const char *input, int length)
+{
+    BIO *b64;
+    BIO *bmem;
+    int n;
+    char *buffer = (char *)malloc(length);
+    memset(buffer, 0, length);
+
+    char *inbuffer = (char *)malloc(length + 1);
+    memset(inbuffer, 0, length + 1);
+    memcpy(inbuffer, input, length);
+    inbuffer[length] = '\n';
+
+    b64 = BIO_new(BIO_f_base64());
+    bmem = BIO_new_mem_buf(inbuffer, length + 1);
+
+    if (b64 != NULL && bmem != NULL) {
+        bmem = BIO_push(b64, bmem);
+
+        n = BIO_read(bmem, buffer, length);
+
+        if (n != 0) {
+            buffer[n - 1] = '\0';
+        } else {
+            free(buffer);
+            buffer = NULL;
+        }
+    } else {
+        free(buffer);
+        buffer = NULL;
+    }
+
+    BIO_free_all(bmem);
+
+    return buffer;
+}
+
+static void reds_do_info_ticket(void)
+{
+    core->term_printf(core, "Ticket Information:");
+    if (ticketing_enabled) {
+        if (strlen(taTicket.password) == 0) {
+            core->term_printf(core, " blocked\n");
+        } else {
+            if (taTicket.expiration_time == INT_MAX) {
+                core->term_printf(core, " expiration NEVER\n");
+            } else {
+                time_t now;
+
+                time(&now);
+                int expired = taTicket.expiration_time < now;
+                if (expired) {
+                    core->term_printf(core, " expiration EXPIRED\n");
+                } else {
+                    core->term_printf(core, " expiration %s\n",
+                                      ctime((time_t *)&(taTicket.expiration_time)));
+                }
+            }
+        }
+    } else {
+        core->term_printf(core, " disabled\n");
+    }
+}
+
+static struct iovec *reds_iovec_skip(struct iovec vec[], int skip, int *vec_size)
+{
+    struct iovec *now = vec;
+
+    while (skip && skip >= now->iov_len) {
+        skip -= now->iov_len;
+        --*vec_size;
+        now++;
+    }
+    now->iov_base = (uint8_t *)now->iov_base + skip;
+    now->iov_len -= skip;
+    return now;
+}
+
+#ifdef RED_STATISTICS
+
+#define STAT_TAB_LEN 4
+#define STAT_VALUE_TABS 7
+
+static void print_stat_tree(uint32_t node_index, int depth)
+{
+    StatNode *node = &reds->stat->nodes[node_index];
+
+    if ((node->flags & STAT_NODE_MASK_SHOW) == STAT_NODE_MASK_SHOW) {
+        core->term_printf(core, "%*s%s", depth * STAT_TAB_LEN, "", node->name);
+        if (node->flags & STAT_NODE_FLAG_VALUE) {
+            core->term_printf(core, ":%*s%llu\n",
+                              (STAT_VALUE_TABS - depth) * STAT_TAB_LEN - strlen(node->name) - 1, "",
+                              node->value);
+        } else {
+            core->term_printf(core, "\n");
+            if (node->first_child_index != INVALID_STAT_REF) {
+                print_stat_tree(node->first_child_index, depth + 1);
+            }
+        }
+    }
+    if (node->next_sibling_index != INVALID_STAT_REF) {
+        print_stat_tree(node->next_sibling_index, depth);
+    }
+}
+
+static void do_info_statistics()
+{
+    core->term_printf(core, "Spice Statistics:\n");
+    print_stat_tree(reds->stat->root_index, 0);
+}
+
+static void do_reset_statistics()
+{
+    StatNode *node;
+    int i;
+
+    for (i = 0; i <= REDS_MAX_STAT_NODES; i++) {
+        node = &reds->stat->nodes[i];
+        if (node->flags & STAT_NODE_FLAG_VALUE) {
+            node->value = 0;
+        }
+    }
+}
+
+void insert_stat_node(StatNodeRef parent, StatNodeRef ref)
+{
+    StatNode *node = &reds->stat->nodes[ref];
+    uint32_t pos = INVALID_STAT_REF;
+    uint32_t node_index;
+    uint32_t *head;
+    StatNode *n;
+
+    node->first_child_index = INVALID_STAT_REF;
+    head = (parent == INVALID_STAT_REF ? &reds->stat->root_index :
+                                         &reds->stat->nodes[parent].first_child_index);
+    node_index = *head;
+    while (node_index != INVALID_STAT_REF && (n = &reds->stat->nodes[node_index]) &&
+                                                     strcmp(node->name, n->name) > 0) {
+        pos = node_index;
+        node_index = n->next_sibling_index;
+    }
+    if (pos == INVALID_STAT_REF) {
+        node->next_sibling_index = *head;
+        *head = ref;
+    } else {
+        n = &reds->stat->nodes[pos];
+        node->next_sibling_index = n->next_sibling_index;
+        n->next_sibling_index = ref;
+    }
+}
+
+StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible)
+{
+    StatNodeRef ref;
+    StatNode *node;
+
+    ASSERT(name && strlen(name) > 0);
+    if (strlen(name) >= sizeof(node->name)) {
+        return INVALID_STAT_REF;
+    }
+    pthread_mutex_lock(&reds->stat_lock);
+    ref = (parent == INVALID_STAT_REF ? reds->stat->root_index :
+                                        reds->stat->nodes[parent].first_child_index);
+    while (ref != INVALID_STAT_REF) {
+        node = &reds->stat->nodes[ref];
+        if (strcmp(name, node->name)) {
+            ref = node->next_sibling_index;
+        } else {
+            pthread_mutex_unlock(&reds->stat_lock);
+            return ref;
+        }
+    }
+    if (reds->stat->num_of_nodes >= REDS_MAX_STAT_NODES || reds->stat == NULL) {
+        pthread_mutex_unlock(&reds->stat_lock);
+        return INVALID_STAT_REF;
+    }
+    reds->stat->generation++;
+    reds->stat->num_of_nodes++;
+    for (ref = 0; ref <= REDS_MAX_STAT_NODES; ref++) {
+        node = &reds->stat->nodes[ref];
+        if (!(node->flags & STAT_NODE_FLAG_ENABLED)) {
+            break;
+        }
+    }
+    ASSERT(!(node->flags & STAT_NODE_FLAG_ENABLED));
+    node->value = 0;
+    node->flags = STAT_NODE_FLAG_ENABLED | (visible ? STAT_NODE_FLAG_VISIBLE : 0);
+    strncpy(node->name, name, sizeof(node->name));
+    insert_stat_node(parent, ref);
+    pthread_mutex_unlock(&reds->stat_lock);
+    return ref;
+}
+
+void stat_remove(StatNode *node)
+{
+    pthread_mutex_lock(&reds->stat_lock);
+    node->flags &= ~STAT_NODE_FLAG_ENABLED;
+    reds->stat->generation++;
+    reds->stat->num_of_nodes--;
+    pthread_mutex_unlock(&reds->stat_lock);
+}
+
+void stat_remove_node(StatNodeRef ref)
+{
+    stat_remove(&reds->stat->nodes[ref]);
+}
+
+uint64_t *stat_add_counter(StatNodeRef parent, const char *name, int visible)
+{
+    StatNodeRef ref = stat_add_node(parent, name, visible);
+    StatNode *node;
+
+    if (ref == INVALID_STAT_REF) {
+        return NULL;
+    }
+    node = &reds->stat->nodes[ref];
+    node->flags |= STAT_NODE_FLAG_VALUE;
+    return &node->value;
+}
+
+void stat_remove_counter(uint64_t *counter)
+{
+    stat_remove((StatNode *)(counter - offsetof(StatNode, value)));
+}
+
+static void reds_update_stat_value(RedsStatValue* stat_value, uint32_t value)
+{
+    stat_value->value = value;
+    stat_value->min = (stat_value->count ? MIN(stat_value->min, value) : value);
+    stat_value->max = MAX(stat_value->max, value);
+    stat_value->average = (stat_value->average * stat_value->count + value) /
+                          (stat_value->count + 1);
+    stat_value->count++;
+}
+
+#endif
+
+void reds_register_channel(Channel *channel)
+{
+    ASSERT(reds);
+    channel->next = reds->channels;
+    reds->channels = channel;
+    reds->num_of_channels++;
+}
+
+void reds_unregister_channel(Channel *channel)
+{
+    Channel **now = &reds->channels;
+
+    while (*now) {
+        if (*now == channel) {
+            *now = channel->next;
+            reds->num_of_channels--;
+            return;
+        }
+        now = &(*now)->next;
+    }
+    red_printf("not found");
+}
+
+static Channel *reds_find_channel(uint32_t type, uint32_t id)
+{
+    Channel *channel = reds->channels;
+    while (channel && !(channel->type == type && channel->id == id)) {
+        channel = channel->next;
+    }
+    return channel;
+}
+
+static void reds_shatdown_channels()
+{
+    Channel *channel = reds->channels;
+    while (channel) {
+        channel->shutdown(channel);
+        channel = channel->next;
+    }
+}
+
+static void reds_mig_cleanup()
+{
+    if (reds->mig_inprogress) {
+        reds->mig_inprogress = FALSE;
+        reds->mig_wait_connect = FALSE;
+        reds->mig_wait_disconnect = FALSE;
+        core->disarm_timer(core, reds->mig_timer);
+        mig->notifier_done(mig, reds->mig_notifier);
+    }
+}
+
+static void reds_reset_vdp()
+{
+    VDIPortState *state = &reds->agent_state;
+
+    while (!ring_is_empty(&state->write_queue)) {
+        VDIPortBuf *buf;
+        RingItem *item;
+
+        item = ring_get_tail(&state->write_queue);
+        ring_remove(item);
+        buf = (VDIPortBuf *)item;
+        buf->free(buf);
+    }
+    state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+    state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+    state->recive_len = sizeof(state->vdi_chunk_header);
+    state->message_recive_len = 0;
+    if (state->current_read_buf) {
+        ring_add(&state->read_bufs, &state->current_read_buf->out_item.link);
+        state->current_read_buf = NULL;
+    }
+    state->client_agent_started = FALSE;
+    state->send_tokens = 0;
+}
+
+static void reds_reset_outgoing()
+{
+    RedsOutgoingData *outgoing = &reds->outgoing;
+    RingItem *ring_item;
+
+    if (outgoing->item) {
+        outgoing->item->release(outgoing->item);
+        outgoing->item = NULL;
+    }
+    while ((ring_item = ring_get_tail(&outgoing->pipe))) {
+        RedsOutItem *out_item = (RedsOutItem *)ring_item;
+        ring_remove(ring_item);
+        out_item->release(out_item);
+    }
+    outgoing->vec_size = 0;
+    outgoing->vec = outgoing->vec_buf;
+}
+
+static void reds_disconnect()
+{
+    if (!reds->peer || reds->disconnecting) {
+        return;
+    }
+
+    red_printf("");
+    LOG_MESSAGE(VD_LOG_INFO, "user disconnected");
+    reds->disconnecting = TRUE;
+    reds_reset_outgoing();
+
+    if (reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF) {
+        ASSERT(vdagent);
+        vdagent->unplug(vdagent, reds->agent_state.plug_ref);
+        reds->agent_state.plug_ref = INVALID_VD_OBJECT_REF;
+        reds_reset_vdp();
+    }
+
+    reds_shatdown_channels();
+    core->set_file_handlers(core, reds->peer->socket, NULL, NULL, NULL);
+    reds->peer->cb_free(reds->peer);
+    reds->peer = NULL;
+    reds->in_handler.shut = TRUE;
+    reds->link_id = 0;
+    reds->serial = 0;
+    reds->ping_id = 0;
+    reds->net_test_id = 0;
+    reds->net_test_stage = NET_TEST_STAGE_INVALID;
+    reds->in_handler.end_pos = 0;
+
+    bitrate_per_sec = ~0;
+    letancy = 0;
+
+    reds_mig_cleanup();
+    reds->disconnecting = FALSE;
+}
+
+static void reds_mig_disconnect()
+{
+    if (reds->peer) {
+        reds_disconnect();
+    } else {
+        reds_mig_cleanup();
+    }
+}
+
+static int handle_incoming(RedsStreamContext *peer, IncomingHandler *handler)
+{
+    for (;;) {
+        uint8_t *buf = handler->buf;
+        uint32_t pos = handler->end_pos;
+        uint8_t *end = buf + pos;
+        RedDataHeader *header;
+        int n;
+        n = peer->cb_read(peer->ctx, buf + pos, RECIVE_BUF_SIZE - pos);
+        if (n <= 0) {
+            if (n == 0) {
+                return -1;
+            }
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+            case EINTR:
+                break;
+            case EPIPE:
+                return -1;
+            default:
+                red_printf("%s", strerror(errno));
+                return -1;
+            }
+        } else {
+            pos += n;
+            end = buf + pos;
+            while (buf + sizeof(RedDataHeader) <= end &&
+                   buf + sizeof(RedDataHeader) + (header = (RedDataHeader *)buf)->size <= end) {
+                buf += sizeof(RedDataHeader) + header->size;
+                handler->handle_message(handler->opaque, header);
+
+                if (handler->shut) {
+                    return -1;
+                }
+            }
+            memmove(handler->buf, buf, (handler->end_pos = end - buf));
+        }
+    }
+}
+
+static int handle_outgoing(RedsStreamContext *peer, OutgoingHandler *handler)
+{
+    if (!handler->length) {
+        return 0;
+    }
+
+    while (handler->length) {
+        int n;
+
+        n = peer->cb_write(peer->ctx, handler->now, handler->length);
+        if (n <= 0) {
+            if (n == 0) {
+                return -1;
+            }
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+            case EINTR:
+                break;
+            case EPIPE:
+                return -1;
+            default:
+                red_printf("%s", strerror(errno));
+                return -1;
+            }
+        } else {
+            handler->now += n;
+            handler->length -= n;
+        }
+    }
+    handler->select(handler->opaque, FALSE);
+    handler->may_write(handler->opaque);
+    return 0;
+}
+
+#define OUTGOING_OK 0
+#define OUTGOING_FAILED -1
+#define OUTGOING_BLOCKED 1
+
+static int outgoing_write(RedsStreamContext *peer, OutgoingHandler *handler, void *in_data,
+                          int length)
+{
+    uint8_t *data = in_data;
+    ASSERT(length <= SEND_BUF_SIZE);
+    if (handler->length) {
+        return OUTGOING_BLOCKED;
+    }
+
+    while (length) {
+        int n = peer->cb_write(peer->ctx, data, length);
+        if (n < 0) {
+            switch (errno) {
+            case EAGAIN:
+                handler->length = length;
+                memcpy(handler->buf, data, length);
+                handler->select(handler->opaque, TRUE);
+                return OUTGOING_OK;
+            case EINTR:
+                break;
+            case EPIPE:
+                return OUTGOING_FAILED;
+            default:
+                red_printf("%s", strerror(errno));
+                return OUTGOING_FAILED;
+            }
+        } else {
+            data += n;
+            length -= n;
+        }
+    }
+    return OUTGOING_OK;
+}
+
+typedef struct SimpleOutItem {
+    RedsOutItem base;
+    RedDataHeader header;
+    uint8_t data[0];
+} SimpleOutItem;
+
+static void reds_prepare_basic_out_item(RedsOutItem *in_item, struct iovec* vec, int *len)
+{
+    SimpleOutItem *item = (SimpleOutItem *)in_item;
+
+    vec[0].iov_base = &item->header;
+    vec[0].iov_len = sizeof(item->header);
+    if (item->header.size) {
+        vec[1].iov_base = item->data;
+        vec[1].iov_len = item->header.size;
+        *len = 2;
+    } else {
+        *len = 1;
+    }
+}
+
+static void reds_free_basic_out_item(RedsOutItem *item)
+{
+    free(item);
+}
+
+static SimpleOutItem *new_simple_out_item(uint32_t type, int message_size)
+{
+    SimpleOutItem *item;
+
+    if (!(item = (SimpleOutItem *)malloc(sizeof(*item) + message_size))) {
+        return NULL;
+    }
+    ring_item_init(&item->base.link);
+    item->base.prepare = reds_prepare_basic_out_item;
+    item->base.release = reds_free_basic_out_item;
+
+    item->header.serial = ++reds->serial;
+    item->header.type = type;
+    item->header.size = message_size;
+    item->header.sub_list = 0;
+
+    return item;
+}
+
+static void reds_push_pipe_item(RedsOutItem *item)
+{
+    ring_add(&reds->outgoing.pipe, &item->link);
+    reds_push();
+}
+
+static void reds_send_channels()
+{
+    RedChannels* channels_info;
+    SimpleOutItem *item;
+    int message_size;
+    Channel *channel;
+    int i;
+
+    message_size = sizeof(RedChannels) + reds->num_of_channels * sizeof(RedChannelInit);
+    if (!(item = new_simple_out_item(RED_CHANNELS_LIST, message_size))) {
+        red_printf("alloc item failed");
+        reds_disconnect();
+        return;
+    }
+    channels_info = (RedChannels *)item->data;
+    channels_info->num_of_channels = reds->num_of_channels;
+    channel = reds->channels;
+
+    for (i = 0; i < reds->num_of_channels; i++) {
+        ASSERT(channel);
+        channels_info->channels[i].type = channel->type;
+        channels_info->channels[i].id = channel->id;
+        channel = channel->next;
+    }
+    reds_push_pipe_item(&item->base);
+}
+
+static void reds_prepare_ping_item(RedsOutItem *in_item, struct iovec* vec, int *len)
+{
+    PingItem *item = (PingItem *)in_item;
+
+    vec[0].iov_base = &item->header;
+    vec[0].iov_len = sizeof(item->header);
+    vec[1].iov_base = &item->ping;
+    vec[1].iov_len = sizeof(item->ping);
+    int size = item->size;
+    int pos = 2;
+    while (size) {
+        ASSERT(pos < REDS_MAX_SEND_IOVEC);
+        int now = MIN(PAGE_SIZE, size);
+        size -= now;
+        vec[pos].iov_base = zero_page;
+        vec[pos].iov_len = now;
+        pos++;
+    }
+    *len = pos;
+}
+
+static void reds_free_ping_item(RedsOutItem *item)
+{
+    free(item);
+}
+
+static int send_ping(int size)
+{
+    struct timespec time_space;
+    PingItem *item;
+
+    if (!reds->peer || !(item = (PingItem *)malloc(sizeof(*item)))) {
+        return FALSE;
+    }
+    ring_item_init(&item->base.link);
+    item->base.prepare = reds_prepare_ping_item;
+    item->base.release = reds_free_ping_item;
+
+    item->header.serial = ++reds->serial;
+    item->header.type = RED_PING;
+    item->header.size = sizeof(item->ping) + size;
+    item->header.sub_list = 0;
+
+    item->ping.id = ++reds->ping_id;
+    clock_gettime(CLOCK_MONOTONIC, &time_space);
+    item->ping.timestamp = time_space.tv_sec * 1000000LL + time_space.tv_nsec / 1000LL;
+
+    item->size = size;
+    reds_push_pipe_item(&item->base);
+    return TRUE;
+}
+
+#ifdef RED_STATISTICS
+
+static void do_ping_client(const char *opt, int has_interval, int interval)
+{
+    if (!reds->peer) {
+        red_printf("not connected to peer");
+        return;
+    }
+
+    if (!opt) {
+        send_ping(0);
+    } else if (!strcmp(opt, "on")) {
+        if (has_interval && interval > 0) {
+            reds->ping_interval = interval * 1000;
+        }
+        core->arm_timer(core, reds->ping_timer, reds->ping_interval);
+        core->term_printf(core, "ping on, interval %u s\n", reds->ping_interval / 1000);
+    } else if (!strcmp(opt, "off")) {
+        core->disarm_timer(core, reds->ping_timer);
+        core->term_printf(core, "ping off\n");
+    } else {
+        core->term_printf(core, "ping invalid option: %s\n", opt);
+        return;
+    }
+}
+
+static void ping_timer_cb()
+{
+    if (!reds->peer) {
+        red_printf("not connected to peer, ping off");
+        core->disarm_timer(core, reds->ping_timer);
+        return;
+    }
+    do_ping_client(NULL, 0, 0);
+    core->arm_timer(core, reds->ping_timer, reds->ping_interval);
+}
+
+static void do_info_rtt_client()
+{
+    core->term_printf(core, "rtt=%uus, min/max/avg=%u/%u/%uus\n", reds->roundtrip_stat.value,
+                      reds->roundtrip_stat.min, reds->roundtrip_stat.max,
+                      reds->roundtrip_stat.average);
+}
+
+#endif
+
+static void reds_send_mouse_mode()
+{
+    RedMouseMode *mouse_mode;
+    SimpleOutItem *item;
+
+    if (!reds->peer) {
+        return;
+    }
+
+    if (!(item = new_simple_out_item(RED_MOUSE_MODE, sizeof(RedMouseMode)))) {
+        red_printf("alloc item failed");
+        reds_disconnect();
+        return;
+    }
+    mouse_mode = (RedMouseMode *)item->data;
+    mouse_mode->supported_modes = RED_MOUSE_MODE_SERVER;
+    if (reds->is_client_mouse_allowed) {
+        mouse_mode->supported_modes |= RED_MOUSE_MODE_CLIENT;
+    }
+    mouse_mode->current_mode = reds->mouse_mode;
+    reds_push_pipe_item(&item->base);
+}
+
+static void reds_set_mouse_mode(uint32_t mode)
+{
+    if (reds->mouse_mode == mode) {
+        return;
+    }
+    reds->mouse_mode = mode;
+    red_dispatcher_set_mouse_mode(reds->mouse_mode);
+    reds_send_mouse_mode();
+}
+
+static void reds_update_mouse_mode()
+{
+    int allowed = 0;
+    int qxl_count = red_dispatcher_qxl_count();
+
+    if ((agent_mouse && vdagent) || (tablet && qxl_count == 1)) {
+        allowed = reds->dispatcher_allows_client_mouse;
+    }
+    if (allowed == reds->is_client_mouse_allowed) {
+        return;
+    }
+    reds->is_client_mouse_allowed = allowed;
+    if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT && !allowed) {
+        reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+        return;
+    }
+    reds_send_mouse_mode();
+}
+
+static void reds_send_agent_connected()
+{
+    SimpleOutItem *item;
+    if (!(item = new_simple_out_item(RED_AGENT_CONNECTED, 0))) {
+        PANIC("alloc item failed");
+    }
+    reds_push_pipe_item(&item->base);
+}
+
+static void reds_send_agent_disconnected()
+{
+    RedAgentDisconnect *disconnect;
+    SimpleOutItem *item;
+
+    if (!(item = new_simple_out_item(RED_AGENT_DISCONNECTED, sizeof(RedAgentDisconnect)))) {
+        PANIC("alloc item failed");
+    }
+    disconnect = (RedAgentDisconnect *)item->data;
+    disconnect->error_code = RED_ERR_OK;
+    reds_push_pipe_item(&item->base);
+}
+
+static void reds_agent_remove()
+{
+    VDIPortInterface *interface = vdagent;
+
+    vdagent = NULL;
+    reds_update_mouse_mode();
+
+    if (!reds->peer || !interface) {
+        return;
+    }
+
+    ASSERT(reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF);
+    interface->unplug(interface, reds->agent_state.plug_ref);
+    reds->agent_state.plug_ref = INVALID_VD_OBJECT_REF;
+
+    if (reds->mig_target) {
+        return;
+    }
+
+    reds_reset_vdp();
+    reds_send_agent_disconnected();
+}
+
+static void reds_send_tokens()
+{
+    RedAgentTokens *tokens;
+    SimpleOutItem *item;
+
+    if (!reds->peer) {
+        return;
+    }
+
+    if (!(item = new_simple_out_item(RED_AGENT_TOKEN, sizeof(RedAgentTokens)))) {
+        red_printf("alloc item failed");
+        reds_disconnect();
+        return;
+    }
+    tokens = (RedAgentTokens *)item->data;
+    tokens->num_tokens = reds->agent_state.num_tokens;
+    reds->agent_state.num_client_tokens += tokens->num_tokens;
+    ASSERT(reds->agent_state.num_client_tokens <= REDS_AGENT_WINDOW_SIZE);
+    reds->agent_state.num_tokens = 0;
+    reds_push_pipe_item(&item->base);
+}
+
+static int write_to_vdi_port()
+{
+    VDIPortState *state = &reds->agent_state;
+    RingItem *ring_item;
+    VDIPortBuf *buf;
+    int total = 0;
+    int n;
+
+    if (reds->agent_state.plug_ref == INVALID_VD_OBJECT_REF || reds->mig_target) {
+        return 0;
+    }
+
+    for (;;) {
+        if (!(ring_item = ring_get_tail(&state->write_queue))) {
+            break;
+        }
+        buf = (VDIPortBuf *)ring_item;
+        n = vdagent->write(vdagent, state->plug_ref, buf->now, buf->write_len);
+        if (n == 0) {
+            break;
+        }
+        total += n;
+        buf->write_len -= n;
+        if (!buf->write_len) {
+            ring_remove(ring_item);
+            buf->free(buf);
+            continue;
+        }
+        buf->now += n;
+    }
+    return total;
+}
+
+static void dispatch_vdi_port_data(int port, VDIReadBuf *buf)
+{
+    VDIPortState *state = &reds->agent_state;
+    switch (port) {
+    case VDP_CLIENT_PORT: {
+        buf->header.serial = ++reds->serial;
+        buf->header.size = buf->len;
+        reds_push_pipe_item(&buf->out_item);
+        break;
+    }
+    case VDP_SERVER_PORT:
+        ring_add(&state->read_bufs, &buf->out_item.link);
+        break;
+    default:
+        ring_add(&state->read_bufs, &buf->out_item.link);
+        red_printf("invalid port");
+        reds_agent_remove();
+    }
+}
+
+static int read_from_vdi_port()
+{
+    VDIPortState *state = &reds->agent_state;
+    VDIReadBuf *dispatch_buf;
+    int total = 0;
+    int n;
+
+    if (reds->mig_target) {
+        return 0;
+    }
+
+    while (reds->agent_state.plug_ref != INVALID_VD_OBJECT_REF) {
+        switch (state->read_state) {
+        case VDI_PORT_READ_STATE_READ_HADER:
+            n = vdagent->read(vdagent, state->plug_ref, state->recive_pos, state->recive_len);
+            if (!n) {
+                return total;
+            }
+            total += n;
+            if ((state->recive_len -= n)) {
+                state->recive_pos += n;
+                break;
+            }
+            state->message_recive_len = state->vdi_chunk_header.size;
+            state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
+        case VDI_PORT_READ_STATE_GET_BUFF: {
+            RingItem *item;
+
+            if (!(item = ring_get_head(&state->read_bufs))) {
+                return total;
+            }
+
+            if (state->vdi_chunk_header.port == VDP_CLIENT_PORT) {
+                if (!state->send_tokens) {
+                    return total;
+                }
+                --state->send_tokens;
+            }
+            ring_remove(item);
+            state->current_read_buf = (VDIReadBuf *)item;
+            state->recive_pos = state->current_read_buf->data;
+            state->recive_len = MIN(state->message_recive_len,
+                                    sizeof(state->current_read_buf->data));
+            state->current_read_buf->len = state->recive_len;
+            state->message_recive_len -= state->recive_len;
+            state->read_state = VDI_PORT_READ_STATE_READ_DATA;
+        }
+        case VDI_PORT_READ_STATE_READ_DATA:
+            n = vdagent->read(vdagent, state->plug_ref, state->recive_pos, state->recive_len);
+            if (!n) {
+                return total;
+            }
+            total += n;
+            if ((state->recive_len -= n)) {
+                state->recive_pos += n;
+                break;
+            }
+            dispatch_buf = state->current_read_buf;
+            state->current_read_buf = NULL;
+            state->recive_pos = NULL;
+            if (state->message_recive_len == 0) {
+                state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+                state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+                state->recive_len = sizeof(state->vdi_chunk_header);
+            } else {
+                state->read_state = VDI_PORT_READ_STATE_GET_BUFF;
+            }
+            dispatch_vdi_port_data(state->vdi_chunk_header.port, dispatch_buf);
+        }
+    }
+    return total;
+}
+
+static void reds_agent_wakeup(VDIPortPlug *plug)
+{
+    while (write_to_vdi_port() || read_from_vdi_port());
+}
+
+static void reds_handle_agent_mouse_event()
+{
+    RingItem *ring_item;
+    VDInternalBuf *buf;
+
+    if (!reds->inputs_state) {
+        return;
+    }
+    if (reds->mig_target || !(ring_item = ring_get_head(&reds->agent_state.internal_bufs))) {
+        reds->inputs_state->pending_mouse_event = TRUE;
+        return;
+    }
+    reds->inputs_state->pending_mouse_event = FALSE;
+    ring_remove(ring_item);
+    buf = (VDInternalBuf *)ring_item;
+    buf->base.now = (uint8_t *)&buf->base.chunk_header;
+    buf->base.write_len = sizeof(VDIChunkHeader) + sizeof(VDAgentMessage) +
+                          sizeof(VDAgentMouseState);
+    buf->u.mouse_state = reds->inputs_state->mouse_state;
+    ring_add(&reds->agent_state.write_queue, &buf->base.link);
+    write_to_vdi_port();
+}
+
+static void add_token()
+{
+    VDIPortState *state = &reds->agent_state;
+
+    if (++state->num_tokens == REDS_TOKENS_TO_SEND) {
+        reds_send_tokens();
+    }
+}
+
+typedef struct MainMigrateData {
+    uint32_t version;
+    uint32_t serial;
+    uint32_t ping_id;
+
+    uint32_t agent_connected;
+    uint32_t client_agent_started;
+    uint32_t num_client_tokens;
+    uint32_t send_tokens;
+
+    uint32_t read_state;
+    VDIChunkHeader vdi_chunk_header;
+    uint32_t recive_len;
+    uint32_t message_recive_len;
+    uint32_t read_buf_len;
+
+    uint32_t write_queue_size;
+} MainMigrateData;
+
+#define MAIN_CHANNEL_MIG_DATA_VERSION 1
+
+typedef struct WriteQueueInfo {
+    uint32_t port;
+    uint32_t len;
+} WriteQueueInfo;
+
+typedef struct SendMainMigrateItem {
+    RedsOutItem base;
+    RedDataHeader header;
+    MainMigrateData data;
+    WriteQueueInfo queue_info[REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES];
+} SendMainMigrateItem;
+
+static void main_channel_send_migrate_data_item(RedsOutItem *in_item, struct iovec* vec_start,
+                                                int *len)
+{
+    SendMainMigrateItem *item = (SendMainMigrateItem *)in_item;
+    VDIPortState *state = &reds->agent_state;
+    struct iovec* vec;
+    int buf_index;
+    RingItem *now;
+
+    vec = vec_start;
+
+    item->header.serial = ++reds->serial;
+    item->header.type = RED_MIGRATE_DATA;
+    item->header.size = sizeof(item->data);
+    item->header.sub_list = 0;
+
+    vec[0].iov_base = &item->header;
+    vec[0].iov_len = sizeof(item->header);
+    vec[1].iov_base = &item->data;
+    vec[1].iov_len = sizeof(item->data);
+
+    vec += 2;
+    *len = 2;
+
+    item->data.version = MAIN_CHANNEL_MIG_DATA_VERSION;
+    item->data.serial = reds->serial;
+    item->data.ping_id = reds->ping_id;
+
+    item->data.agent_connected = !!state->plug_ref;
+    item->data.client_agent_started = state->client_agent_started;
+    item->data.num_client_tokens = state->num_client_tokens;
+    item->data.send_tokens = state->send_tokens;
+
+    item->data.read_state = state->read_state;
+    item->data.vdi_chunk_header = state->vdi_chunk_header;
+    item->data.recive_len = state->recive_len;
+    item->data.message_recive_len = state->message_recive_len;
+
+
+    if (state->current_read_buf) {
+        item->data.read_buf_len = state->current_read_buf->len;
+        if ((vec->iov_len = item->data.read_buf_len - item->data.recive_len)) {
+            vec->iov_base = state->current_read_buf->data;
+            item->header.size += vec->iov_len;
+            vec++;
+            (*len)++;
+        }
+    } else {
+        item->data.read_buf_len = 0;
+    }
+
+    now = &state->write_queue;
+    item->data.write_queue_size = 0;
+    while ((now = ring_prev(&state->write_queue, now))) {
+        item->data.write_queue_size++;
+    }
+    if (!item->data.write_queue_size) {
+        return;
+    }
+    ASSERT(item->data.write_queue_size <= sizeof(item->queue_info) / sizeof(item->queue_info[0]));
+    vec->iov_base = item->queue_info;
+    vec->iov_len = item->data.write_queue_size * sizeof(item->queue_info[0]);
+    item->header.size += vec->iov_len;
+    vec++;
+    (*len)++;
+
+    buf_index = 0;
+    now = &state->write_queue;
+    while ((now = ring_prev(&state->write_queue, now))) {
+        VDIPortBuf *buf = (VDIPortBuf *)now;
+        item->queue_info[buf_index].port = buf->chunk_header.port;
+        item->queue_info[buf_index++].len = buf->write_len;
+        ASSERT(vec - vec_start < REDS_MAX_SEND_IOVEC);
+        vec->iov_base = buf->now;
+        vec->iov_len = buf->write_len;
+        item->header.size += vec->iov_len;
+        vec++;
+        (*len)++;
+    }
+}
+
+static void main_channelrelease_migrate_data_item(RedsOutItem *in_item)
+{
+    SendMainMigrateItem *item = (SendMainMigrateItem *)in_item;
+    free(item);
+}
+
+static void main_channel_push_migrate_data_item()
+{
+    SendMainMigrateItem *item;
+
+    if (!(item = (SendMainMigrateItem *)malloc(sizeof(*item)))) {
+        PANIC("malloc failed");
+    }
+    memset(item, 0, sizeof(*item));
+    ring_item_init(&item->base.link);
+    item->base.prepare = main_channel_send_migrate_data_item;
+    item->base.release = main_channelrelease_migrate_data_item;
+
+    reds_push_pipe_item((RedsOutItem *)item);
+}
+
+static int main_channel_restore_vdi_read_state(MainMigrateData *data, uint8_t **in_pos,
+                                               uint8_t *end)
+{
+    VDIPortState *state = &reds->agent_state;
+    uint8_t *pos = *in_pos;
+    RingItem *ring_item;
+
+    state->read_state = data->read_state;
+    state->vdi_chunk_header = data->vdi_chunk_header;
+    state->recive_len = data->recive_len;
+    state->message_recive_len = data->message_recive_len;
+
+    switch (state->read_state) {
+    case VDI_PORT_READ_STATE_READ_HADER:
+        if (data->read_buf_len) {
+            red_printf("unexpected recive buf");
+            reds_disconnect();
+            return FALSE;
+        }
+        state->recive_pos = (uint8_t *)(&state->vdi_chunk_header + 1) - state->recive_len;
+        break;
+    case VDI_PORT_READ_STATE_GET_BUFF:
+        if (state->message_recive_len > state->vdi_chunk_header.size) {
+            red_printf("invalid message recive len");
+            reds_disconnect();
+            return FALSE;
+        }
+
+        if (data->read_buf_len) {
+            red_printf("unexpected recive buf");
+            reds_disconnect();
+            return FALSE;
+        }
+        break;
+    case VDI_PORT_READ_STATE_READ_DATA: {
+        VDIReadBuf *buff;
+        uint32_t n;
+
+        if (!data->read_buf_len) {
+            red_printf("read state and read_buf_len == 0");
+            reds_disconnect();
+            return FALSE;
+        }
+
+        if (state->message_recive_len > state->vdi_chunk_header.size) {
+            red_printf("invalid message recive len");
+            reds_disconnect();
+            return FALSE;
+        }
+
+
+        if (!(ring_item = ring_get_head(&state->read_bufs))) {
+            red_printf("get read buf failed");
+            reds_disconnect();
+            return FALSE;
+        }
+
+        ring_remove(ring_item);
+        buff = state->current_read_buf = (VDIReadBuf *)ring_item;
+        buff->len = data->read_buf_len;
+        n = buff->len - state->recive_len;
+        if (buff->len > RED_AGENT_MAX_DATA_SIZE || n > RED_AGENT_MAX_DATA_SIZE) {
+            red_printf("bad read position");
+            reds_disconnect();
+            return FALSE;
+        }
+        memcpy(buff->data, pos, n);
+        pos += n;
+        state->recive_pos = buff->data + n;
+        break;
+    }
+    default:
+        red_printf("invalid read state");
+        reds_disconnect();
+        return FALSE;
+    }
+    *in_pos = pos;
+    return TRUE;
+}
+
+static void free_tmp_internal_buf(VDIPortBuf *buf)
+{
+    free(buf);
+}
+
+static int main_channel_restore_vdi_wqueue(MainMigrateData *data, uint8_t *pos, uint8_t *end)
+{
+    VDIPortState *state = &reds->agent_state;
+    WriteQueueInfo *inf;
+    WriteQueueInfo *inf_end;
+    RingItem *ring_item;
+
+    if (!data->write_queue_size) {
+        return TRUE;
+    }
+
+    inf = (WriteQueueInfo *)pos;
+    inf_end = inf + data->write_queue_size;
+    pos = (uint8_t *)inf_end;
+    if (pos > end) {
+        red_printf("access violation");
+        reds_disconnect();
+        return FALSE;
+    }
+
+    for (; inf < inf_end; inf++) {
+        if (pos + inf->len > end) {
+            red_printf("access violation");
+            reds_disconnect();
+            return FALSE;
+        }
+        if (inf->port == VDP_SERVER_PORT) {
+            VDInternalBuf *buf;
+
+            if (inf->len > sizeof(*buf) - OFFSETOF(VDInternalBuf, header)) {
+                red_printf("bad buffer len");
+                reds_disconnect();
+                return FALSE;
+            }
+            if (!(buf = malloc(sizeof(VDInternalBuf)))) {
+                red_printf("no internal buff");
+                reds_disconnect();
+                return FALSE;
+            }
+            ring_item_init(&buf->base.link);
+            buf->base.free = free_tmp_internal_buf;
+            buf->base.now = (uint8_t *)&buf->base.chunk_header;
+            buf->base.write_len = inf->len;
+            memcpy(buf->base.now, pos, buf->base.write_len);
+            ring_add(&reds->agent_state.write_queue, &buf->base.link);
+        } else if (inf->port == VDP_CLIENT_PORT) {
+            VDAgentExtBuf *buf;
+
+            state->num_tokens--;
+            if (inf->len > sizeof(*buf) - OFFSETOF(VDAgentExtBuf, buf)) {
+                red_printf("bad buffer len");
+                reds_disconnect();
+                return FALSE;
+            }
+            if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
+                red_printf("no external buff");
+                reds_disconnect();
+                return FALSE;
+            }
+            ring_remove(ring_item);
+            buf = (VDAgentExtBuf *)ring_item;
+            memcpy(&buf->buf, pos, inf->len);
+            buf->base.now = (uint8_t *)buf->buf;
+            buf->base.write_len = inf->len;
+            ring_add(&reds->agent_state.write_queue, &buf->base.link);
+        } else {
+            red_printf("invalid data");
+            reds_disconnect();
+            return FALSE;
+        }
+        pos += inf->len;
+    }
+    return TRUE;
+}
+
+static void main_channel_recive_migrate_data(MainMigrateData *data, uint8_t *end)
+{
+    VDIPortState *state = &reds->agent_state;
+    uint8_t *pos;
+
+    if (data->version != MAIN_CHANNEL_MIG_DATA_VERSION) {
+        red_printf("version mismatch");
+        reds_disconnect();
+        return;
+    }
+
+    reds->serial = data->serial;
+    reds->ping_id = data->ping_id;
+
+    state->num_client_tokens = data->num_client_tokens;
+    ASSERT(state->num_client_tokens + data->write_queue_size <= REDS_AGENT_WINDOW_SIZE +
+                                                                REDS_NUM_INTERNAL_AGENT_MESSAGES);
+    state->num_tokens = REDS_AGENT_WINDOW_SIZE - state->num_client_tokens;
+    state->send_tokens = data->send_tokens;
+
+
+    if (!data->agent_connected) {
+        if (state->plug_ref) {
+            reds_send_agent_connected();
+        }
+        return;
+    }
+
+    if (state->plug_ref == INVALID_VD_OBJECT_REF) {
+        reds_send_agent_disconnected();
+        return;
+    }
+
+    if (state->plug_generation > 1) {
+        reds_send_agent_disconnected();
+        reds_send_agent_connected();
+        return;
+    }
+
+    state->client_agent_started = data->client_agent_started;
+
+    pos = (uint8_t *)(data + 1);
+
+    if (!main_channel_restore_vdi_read_state(data, &pos, end)) {
+        return;
+    }
+
+    main_channel_restore_vdi_wqueue(data, pos, end);
+    ASSERT(state->num_client_tokens + state->num_tokens == REDS_AGENT_WINDOW_SIZE);
+}
+
+static void reds_main_handle_message(void *opaque, RedDataHeader *message)
+{
+    switch (message->type) {
+    case REDC_AGENT_START: {
+        RedcAgentTokens *agent_start;
+
+        red_printf("agent start");
+        if (!reds->peer) {
+            return;
+        }
+        agent_start = (RedcAgentTokens *)(message + 1);
+        reds->agent_state.client_agent_started = TRUE;
+        reds->agent_state.send_tokens = agent_start->num_tokens;
+        read_from_vdi_port();
+        break;
+    }
+    case REDC_AGENT_DATA: {
+        RingItem *ring_item;
+        VDAgentExtBuf *buf;
+
+        if (!reds->agent_state.num_client_tokens) {
+            red_printf("token vailoation");
+            reds_disconnect();
+            break;
+        }
+        --reds->agent_state.num_client_tokens;
+
+        if (!vdagent) {
+            add_token();
+            break;
+        }
+
+        if (!reds->agent_state.client_agent_started) {
+            red_printf("REDC_AGENT_DATA race");
+            add_token();
+            break;
+        }
+
+        if (message->size > RED_AGENT_MAX_DATA_SIZE) {
+            red_printf("invalid agent message");
+            reds_disconnect();
+            break;
+        }
+
+        if (!(ring_item = ring_get_head(&reds->agent_state.external_bufs))) {
+            red_printf("no agent free bufs");
+            reds_disconnect();
+            break;
+        }
+        ring_remove(ring_item);
+        buf = (VDAgentExtBuf *)ring_item;
+        buf->base.now = (uint8_t *)&buf->base.chunk_header.port;
+        buf->base.write_len = message->size + sizeof(VDIChunkHeader);
+        buf->base.chunk_header.size = message->size;
+        memcpy(buf->buf, message + 1, message->size);
+        ring_add(&reds->agent_state.write_queue, ring_item);
+        write_to_vdi_port();
+        break;
+    }
+    case REDC_AGENT_TOKEN: {
+        RedcAgentTokens *token;
+
+        if (!reds->agent_state.client_agent_started) {
+            red_printf("REDC_AGENT_TOKEN race");
+            break;
+        }
+
+        token = (RedcAgentTokens *)(message + 1);
+        reds->agent_state.send_tokens += token->num_tokens;
+        read_from_vdi_port();
+        break;
+    }
+    case REDC_ATTACH_CHANNELS:
+        reds_send_channels();
+        break;
+    case REDC_MIGRATE_CONNECTED:
+        red_printf("connected");
+        if (reds->mig_wait_connect) {
+            reds_mig_cleanup();
+        }
+        break;
+    case REDC_MIGRATE_CONNECT_ERROR:
+        red_printf("mig connect error");
+        if (reds->mig_wait_connect) {
+            reds_mig_cleanup();
+        }
+        break;
+    case REDC_MOUSE_MODE_REQUEST: {
+        switch (((RedcMouseModeRequest *)(message + 1))->mode) {
+        case RED_MOUSE_MODE_CLIENT:
+            if (reds->is_client_mouse_allowed) {
+                reds_set_mouse_mode(RED_MOUSE_MODE_CLIENT);
+            } else {
+                red_printf("client mouse is disabled");
+            }
+            break;
+        case RED_MOUSE_MODE_SERVER:
+            reds_set_mouse_mode(RED_MOUSE_MODE_SERVER);
+            break;
+        default:
+            red_printf("unsupported mouse mode");
+        }
+        break;
+    }
+    case REDC_PONG: {
+        RedPing *ping = (RedPing *)(message + 1);
+        uint64_t roundtrip;
+        struct timespec ts;
+
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        roundtrip = ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL - ping->timestamp;
+
+        if (ping->id == reds->net_test_id) {
+            switch (reds->net_test_stage) {
+            case NET_TEST_STAGE_WARMUP:
+                reds->net_test_id++;
+                reds->net_test_stage = NET_TEST_STAGE_LATENCY;
+                break;
+            case NET_TEST_STAGE_LATENCY:
+                reds->net_test_id++;
+                reds->net_test_stage = NET_TEST_STAGE_RATE;
+                letancy = roundtrip;
+                break;
+            case NET_TEST_STAGE_RATE:
+                reds->net_test_id = 0;
+                if (roundtrip <= letancy) {
+                    // probably high load on client or server result with incorrect values
+                    letancy = 0;
+                    red_printf("net test: invalid values, letancy %lu roundtrip %lu. assuming high"
+                               "bendwidth", letancy, roundtrip);
+                    break;
+                }
+                bitrate_per_sec = (uint64_t)(NET_TEST_BYTES * 8) * 1000000 / (roundtrip - letancy);
+                red_printf("net test: letancy %f ms, bitrate %lu bps (%f Mbps)%s",
+                           (double)letancy / 1000,
+                           bitrate_per_sec,
+                           (double)bitrate_per_sec / 1024 / 1024,
+                           IS_LOW_BANDWIDTH() ? " LOW BANDWIDTH" : "");
+                reds->net_test_stage = NET_TEST_STAGE_INVALID;
+                break;
+            default:
+                red_printf("invalid net test stage, ping id %d test id %d stage %d",
+                           ping->id,
+                           reds->net_test_id,
+                           reds->net_test_stage);
+            }
+            break;
+        }
+#ifdef RED_STATISTICS
+        reds_update_stat_value(&reds->roundtrip_stat, roundtrip);
+        do_info_rtt_client();
+#endif
+        break;
+    }
+    case REDC_MIGRATE_FLUSH_MARK:
+        main_channel_push_migrate_data_item();
+        break;
+    case REDC_MIGRATE_DATA:
+        main_channel_recive_migrate_data((MainMigrateData *)(message + 1),
+                                         (uint8_t *)(message + 1) + message->size);
+        reds->mig_target = FALSE;
+        while (write_to_vdi_port() || read_from_vdi_port());
+        break;
+    case REDC_DISCONNECTING:
+        break;
+    default:
+        red_printf("unexpected type %d", message->type);
+    }
+}
+
+static void reds_main_read(void *data)
+{
+    if (handle_incoming(reds->peer, &reds->in_handler)) {
+        reds_disconnect();
+    }
+}
+
+static int reds_send_data()
+{
+    RedsOutgoingData *outgoing = &reds->outgoing;
+    int n;
+
+    if (!outgoing->item) {
+        return TRUE;
+    }
+
+    ASSERT(outgoing->vec_size);
+    for (;;) {
+        if ((n = reds->peer->cb_writev(reds->peer->ctx, outgoing->vec, outgoing->vec_size)) == -1) {
+            switch (errno) {
+            case EAGAIN:
+                core->set_file_handlers(core, reds->peer->socket, reds_main_read, reds_main_write,
+                                        NULL);
+                return FALSE;
+            case EINTR:
+                break;
+            case EPIPE:
+                reds_disconnect();
+                return FALSE;
+            default:
+                red_printf("%s", strerror(errno));
+                reds_disconnect();
+                return FALSE;
+            }
+        } else {
+            outgoing->vec = reds_iovec_skip(outgoing->vec, n, &outgoing->vec_size);
+            if (!outgoing->vec_size) {
+                outgoing->item->release(outgoing->item);
+                outgoing->item = NULL;
+                outgoing->vec = outgoing->vec_buf;
+                return TRUE;
+            }
+        }
+    }
+}
+
+static void reds_push()
+{
+    RedsOutgoingData *outgoing = &reds->outgoing;
+    RingItem *item;
+
+    for (;;) {
+        if (!reds->peer || outgoing->item || !(item = ring_get_tail(&outgoing->pipe))) {
+            return;
+        }
+        ring_remove(item);
+        outgoing->item = (RedsOutItem *)item;
+        outgoing->item->prepare(outgoing->item, outgoing->vec_buf, &outgoing->vec_size);
+        reds_send_data();
+    }
+}
+
+static void reds_main_write(void *data)
+{
+    RedsOutgoingData *outgoing = &reds->outgoing;
+
+    if (reds_send_data()) {
+        reds_push();
+        if (!outgoing->item) {
+            core->set_file_handlers(core, reds->peer->socket, reds_main_read, NULL, NULL);
+        }
+    }
+}
+
+static int sync_write(RedsStreamContext *peer, void *in_buf, size_t n)
+{
+    uint8_t *buf = (uint8_t *)in_buf;
+    while (n) {
+        int now = peer->cb_write(peer->ctx, buf, n);
+        if (now <= 0) {
+            if (now == -1 && (errno == EINTR || errno == EAGAIN)) {
+                continue;
+            }
+            return FALSE;
+        }
+        n -= now;
+        buf += now;
+    }
+    return TRUE;
+}
+
+static int reds_send_link_ack(RedLinkInfo *link)
+{
+    RedLinkHeader header;
+    RedLinkReply ack;
+    Channel *channel;
+    BUF_MEM *bmBuf;
+    BIO *bio;
+    int ret;
+
+    header.magic = RED_MAGIC;
+    header.size = sizeof(ack);
+    header.major_version = RED_VERSION_MAJOR;
+    header.minor_version = RED_VERSION_MINOR;
+
+    ack.error = RED_ERR_OK;
+
+    if ((channel = reds_find_channel(link->link_mess->channel_type, 0))) {
+        ack.num_common_caps = channel->num_common_caps;
+        ack.num_channel_caps = channel->num_caps;
+        header.size += (ack.num_common_caps + ack.num_channel_caps) * sizeof(uint32_t);
+    } else {
+        ack.num_common_caps = 0;
+        ack.num_channel_caps = 0;
+    }
+    ack.caps_offset = sizeof(RedLinkReply);
+
+    if (!(link->tiTicketing.rsa = RSA_new())) {
+        red_printf("RSA nes failed");
+        return FALSE;
+    }
+
+    if (!(bio = BIO_new(BIO_s_mem()))) {
+        red_printf("BIO new failed");
+        return FALSE;
+    }
+
+    RSA_generate_key_ex(link->tiTicketing.rsa, RED_TICKET_KEY_PAIR_LENGTH, link->tiTicketing.bn,
+                        NULL);
+    link->tiTicketing.rsa_size = RSA_size(link->tiTicketing.rsa);
+
+    i2d_RSA_PUBKEY_bio(bio, link->tiTicketing.rsa);
+    BIO_get_mem_ptr(bio, &bmBuf);
+    memcpy(ack.pub_key, bmBuf->data, sizeof(ack.pub_key));
+
+    ret = sync_write(link->peer, &header, sizeof(header)) && sync_write(link->peer, &ack,
+                                                                        sizeof(ack));
+    if (channel) {
+        ret = ret && sync_write(link->peer, channel->common_caps,
+                                channel->num_common_caps * sizeof(uint32_t)) &&
+              sync_write(link->peer, channel->caps, channel->num_caps * sizeof(uint32_t));
+    }
+    BIO_free(bio);
+    return ret;
+}
+
+static int reds_send_link_error(RedLinkInfo *link, uint32_t error)
+{
+    RedLinkHeader header;
+    RedLinkReply reply;
+
+    header.magic = RED_MAGIC;
+    header.size = sizeof(reply);
+    header.major_version = RED_VERSION_MAJOR;
+    header.minor_version = RED_VERSION_MINOR;
+    memset(&reply, 0, sizeof(reply));
+    reply.error = error;
+    return sync_write(link->peer, &header, sizeof(header)) && sync_write(link->peer, &reply,
+                                                                         sizeof(reply));
+}
+
+static void reds_show_new_channel(RedLinkInfo *link)
+{
+    red_printf("channel %d:%d, connected sucessfully, over %s link",
+               link->link_mess->channel_type,
+               link->link_mess->channel_id,
+               link->peer->ssl == NULL ? "Non Secure" : "Secure");
+}
+
+static void reds_send_link_result(RedLinkInfo *link, uint32_t error)
+{
+    sync_write(link->peer, &error, sizeof(error));
+}
+
+static void reds_start_net_test()
+{
+    if (!reds->peer || reds->net_test_id) {
+        return;
+    }
+
+    if (send_ping(NET_TEST_WARMUP_BYTES) && send_ping(0) && send_ping(NET_TEST_BYTES)) {
+        reds->net_test_id = reds->ping_id - 2;
+        reds->net_test_stage = NET_TEST_STAGE_WARMUP;
+    }
+}
+
+static void reds_handle_main_link(RedLinkInfo *link)
+{
+    uint32_t connection_id;
+
+    red_printf("");
+
+    reds_disconnect();
+
+    if (!link->link_mess->connection_id) {
+        reds_send_link_result(link, RED_ERR_OK);
+        while((connection_id = rand()) == 0);
+        reds->agent_state.num_tokens = 0;
+        reds->agent_state.send_tokens = 0;
+        memcpy(&(reds->taTicket), &taTicket, sizeof(reds->taTicket));
+        reds->mig_target = FALSE;
+    } else {
+        if (link->link_mess->connection_id != reds->link_id) {
+            reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+            reds_release_link(link);
+            return;
+        }
+        reds_send_link_result(link, RED_ERR_OK);
+        connection_id = link->link_mess->connection_id;
+        reds->mig_target = TRUE;
+    }
+
+    reds->link_id = connection_id;
+    reds->mig_inprogress = FALSE;
+    reds->mig_wait_connect = FALSE;
+    reds->mig_wait_disconnect = FALSE;
+    reds->peer = link->peer;
+    reds->in_handler.shut = FALSE;
+    if (reds->mig_target) {
+        LOG_MESSAGE(VD_LOG_INFO, "migrate connection");
+    } else {
+        LOG_MESSAGE(VD_LOG_INFO, "new user connection");
+    }
+
+    reds_show_new_channel(link);
+    __reds_release_link(link);
+    if (vdagent) {
+        reds->agent_state.plug_ref = vdagent->plug(vdagent, &reds->agent_state.plug);
+        if (reds->agent_state.plug_ref == INVALID_VD_OBJECT_REF) {
+            PANIC("vdagent plug failed");
+        }
+        reds->agent_state.plug_generation++;
+    }
+    core->set_file_handlers(core, reds->peer->socket, reds_main_read, NULL, NULL);
+
+    if (!reds->mig_target) {
+        SimpleOutItem *item;
+        RedInit *init;
+
+        if (!(item = new_simple_out_item(RED_INIT, sizeof(RedInit)))) {
+            red_printf("alloc item failed");
+            reds_disconnect();
+            return;
+        }
+        init = (RedInit *)item->data;
+        init->session_id = connection_id;
+        init->display_channels_hint = red_dispatcher_count();
+        init->current_mouse_mode = reds->mouse_mode;
+        init->supported_mouse_modes = RED_MOUSE_MODE_SERVER;
+        if (reds->is_client_mouse_allowed) {
+            init->supported_mouse_modes |= RED_MOUSE_MODE_CLIENT;
+        }
+        init->agent_connected = !!vdagent;
+        init->agent_tokens = REDS_AGENT_WINDOW_SIZE;
+        reds->agent_state.num_client_tokens = REDS_AGENT_WINDOW_SIZE;
+        init->multi_media_time = reds_get_mm_time() - MM_TIME_DELTA;
+        init->ram_hint = red_dispatcher_qxl_ram_size();
+        reds_push_pipe_item(&item->base);
+        reds_start_net_test();
+    }
+}
+
+#define RED_MOUSE_STATE_TO_LOCAL(state)     \
+    ((state & REDC_LBUTTON_MASK) |          \
+     ((state & REDC_MBUTTON_MASK) << 1) |   \
+     ((state & REDC_RBUTTON_MASK) >> 1))
+
+#define RED_MOUSE_BUTTON_STATE_TO_AGENT(state)                      \
+    (((state & REDC_LBUTTON_MASK) ? VD_AGENT_LBUTTON_MASK : 0) |    \
+     ((state & REDC_MBUTTON_MASK) ? VD_AGENT_MBUTTON_MASK : 0) |    \
+     ((state & REDC_RBUTTON_MASK) ? VD_AGENT_RBUTTON_MASK : 0))
+
+static void activate_modifiers_watch()
+{
+    core->arm_timer(core, reds->key_modifiers_timer, KEY_MODIFIERS_TTL);
+}
+
+static void push_key_scan(uint8_t scan)
+{
+    if (!keyboard) {
+        return;
+    }
+    keyboard->push_scan_freg(keyboard, scan);
+}
+
+static void inputs_handle_input(void *opaque, RedDataHeader *header)
+{
+    InputsState *state = (InputsState *)opaque;
+    uint8_t *buf = (uint8_t *)(header + 1);
+
+    switch (header->type) {
+    case REDC_INPUTS_KEY_DOWN: {
+        RedcKeyDown *key_up = (RedcKeyDown *)buf;
+        if (key_up->code == CAPS_LOCK_SCAN_CODE || key_up->code == NUM_LOCK_SCAN_CODE ||
+            key_up->code == SCROLL_LOCK_SCAN_CODE) {
+            activate_modifiers_watch();
+        }
+    }
+    case REDC_INPUTS_KEY_UP: {
+        RedcKeyDown *key_down = (RedcKeyDown *)buf;
+        uint8_t *now = (uint8_t *)&key_down->code;
+        uint8_t *end = now + sizeof(key_down->code);
+        for (; now < end && *now; now++) {
+            push_key_scan(*now);
+        }
+        break;
+    }
+    case REDC_INPUTS_MOUSE_MOTION: {
+        RedcMouseMotion *mouse_motion = (RedcMouseMotion *)buf;
+
+        if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
+            RedDataHeader header;
+
+            header.serial = ++state->serial;
+            header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+            header.size = 0;
+            header.sub_list = 0;
+            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+                                                                                != OUTGOING_OK) {
+                red_printf("motion ack failed");
+                reds_disconnect();
+            }
+        }
+        if (mouse && reds->mouse_mode == RED_MOUSE_MODE_SERVER) {
+            mouse->moution(mouse, mouse_motion->dx, mouse_motion->dy, 0,
+                           RED_MOUSE_STATE_TO_LOCAL(mouse_motion->buttons_state));
+        }
+        break;
+    }
+    case REDC_INPUTS_MOUSE_POSITION: {
+        RedcMousePosition *pos = (RedcMousePosition *)buf;
+
+        if (++state->motion_count % RED_MOTION_ACK_BUNCH == 0) {
+            RedDataHeader header;
+
+            header.serial = ++state->serial;
+            header.type = RED_INPUTS_MOUSE_MOTION_ACK;
+            header.size = 0;
+            header.sub_list = 0;
+            if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+                                                                                != OUTGOING_OK) {
+                red_printf("position ack failed");
+                reds_disconnect();
+            }
+        }
+        if (reds->mouse_mode != RED_MOUSE_MODE_CLIENT) {
+            break;
+        }
+        ASSERT((agent_mouse && vdagent) || tablet);
+        if (!agent_mouse || !vdagent) {
+            tablet->position(tablet, pos->x, pos->y, RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
+            break;
+        }
+        VDAgentMouseState *mouse_state = &state->mouse_state;
+        mouse_state->x = pos->x;
+        mouse_state->y = pos->y;
+        mouse_state->buttons = RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
+        mouse_state->display_id = pos->display_id;
+        reds_handle_agent_mouse_event();
+        break;
+    }
+    case REDC_INPUTS_MOUSE_PRESS: {
+        RedcMousePress *mouse_press = (RedcMousePress *)buf;
+        int dz = 0;
+        if (mouse_press->button == REDC_MOUSE_UBUTTON) {
+            dz = -1;
+        } else if (mouse_press->button == REDC_MOUSE_DBUTTON) {
+            dz = 1;
+        }
+        if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+            if (agent_mouse && vdagent) {
+                reds->inputs_state->mouse_state.buttons =
+                    RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state) |
+                    (dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
+                    (dz == 1 ? VD_AGENT_DBUTTON_MASK : 0);
+                reds_handle_agent_mouse_event();
+            } else if (tablet) {
+                tablet->wheel(tablet, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+            }
+        } else if (mouse) {
+            mouse->moution(mouse, 0, 0, dz, RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
+        }
+        break;
+    }
+    case REDC_INPUTS_MOUSE_RELEASE: {
+        RedcMouseRelease *mouse_release = (RedcMouseRelease *)buf;
+        if (reds->mouse_mode == RED_MOUSE_MODE_CLIENT) {
+            if (agent_mouse && vdagent) {
+                reds->inputs_state->mouse_state.buttons =
+                    RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
+                reds_handle_agent_mouse_event();
+            } else if (tablet) {
+                tablet->buttons(tablet, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+            }
+        } else if (mouse) {
+            mouse->buttons(mouse, RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
+        }
+        break;
+    }
+    case REDC_INPUTS_KEY_MODIFAIERS: {
+        RedcKeyModifiers *modifiers = (RedcKeyModifiers *)buf;
+        if (!keyboard) {
+            break;
+        }
+        uint8_t leds = keyboard->get_leds(keyboard);
+        if ((modifiers->modifiers & RED_SCROLL_LOCK_MODIFIER) !=
+                                                                (leds & RED_SCROLL_LOCK_MODIFIER)) {
+            push_key_scan(SCROLL_LOCK_SCAN_CODE);
+            push_key_scan(SCROLL_LOCK_SCAN_CODE | 0x80);
+        }
+        if ((modifiers->modifiers & RED_NUM_LOCK_MODIFIER) != (leds & RED_NUM_LOCK_MODIFIER)) {
+            push_key_scan(NUM_LOCK_SCAN_CODE);
+            push_key_scan(NUM_LOCK_SCAN_CODE | 0x80);
+        }
+        if ((modifiers->modifiers & RED_CAPS_LOCK_MODIFIER) != (leds & RED_CAPS_LOCK_MODIFIER)) {
+            push_key_scan(CAPS_LOCK_SCAN_CODE);
+            push_key_scan(CAPS_LOCK_SCAN_CODE | 0x80);
+        }
+        activate_modifiers_watch();
+        break;
+    }
+    case REDC_DISCONNECTING:
+        break;
+    default:
+        red_printf("unexpected type %d", header->type);
+    }
+}
+
+void reds_set_client_mouse_allowed(int is_client_mouse_allowed, int x_res, int y_res)
+{
+    reds->monitor_mode.x_res = x_res;
+    reds->monitor_mode.y_res = y_res;
+    reds->dispatcher_allows_client_mouse = is_client_mouse_allowed;
+    reds_update_mouse_mode();
+    if (reds->is_client_mouse_allowed && tablet) {
+        tablet->set_logical_size(tablet, reds->monitor_mode.x_res, reds->monitor_mode.y_res);
+    }
+}
+
+static void inputs_relase_keys(void)
+{
+    push_key_scan(0x2a | 0x80); //LSHIFT
+    push_key_scan(0x36 | 0x80); //RSHIFT
+    push_key_scan(0xe0); push_key_scan(0x1d | 0x80); //RCTRL
+    push_key_scan(0x1d | 0x80); //LCTRL
+    push_key_scan(0xe0); push_key_scan(0x38 | 0x80); //RALT
+    push_key_scan(0x38 | 0x80); //LALT
+}
+
+static void inputs_read(void *data)
+{
+    InputsState *inputs_state = (InputsState *)data;
+    if (handle_incoming(inputs_state->peer, &inputs_state->in_handler)) {
+        inputs_relase_keys();
+        core->set_file_handlers(core, inputs_state->peer->socket, NULL, NULL, NULL);
+        if (inputs_state->channel) {
+            inputs_state->channel->data = NULL;
+            reds->inputs_state = NULL;
+        }
+        inputs_state->peer->cb_free(inputs_state->peer);
+        free(inputs_state);
+    }
+}
+
+static void inputs_write(void *data)
+{
+    InputsState *inputs_state = (InputsState *)data;
+
+    red_printf("");
+    if (handle_outgoing(inputs_state->peer, &inputs_state->out_handler)) {
+        reds_disconnect();
+    }
+}
+
+static void inputs_shutdown(Channel *channel)
+{
+    InputsState *state = (InputsState *)channel->data;
+    if (state) {
+        state->in_handler.shut = TRUE;
+        shutdown(state->peer->socket, SHUT_RDWR);
+        channel->data = NULL;
+        state->channel = NULL;
+        reds->inputs_state = NULL;
+    }
+}
+
+static void inputs_migrate(Channel *channel)
+{
+    InputsState *state = (InputsState *)channel->data;
+    RedDataHeader header;
+    RedMigrate migrate;
+
+    red_printf("");
+    header.serial = ++state->serial;
+    header.type = RED_MIGRATE;
+    header.size = sizeof(migrate);
+    header.sub_list = 0;
+    migrate.flags = 0;
+    if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(header))
+                                                                            != OUTGOING_OK ||
+        outgoing_write(state->peer, &state->out_handler, &migrate, sizeof(migrate))
+                                                                            != OUTGOING_OK) {
+        red_printf("write failed");
+    }
+}
+
+static void inputs_select(void *opaque, int select)
+{
+    InputsState *inputs_state;
+    red_printf("");
+
+    inputs_state = (InputsState *)opaque;
+    if (select) {
+        core->set_file_handlers(core, inputs_state->peer->socket, inputs_read, inputs_write,
+                                inputs_state);
+    } else {
+        core->set_file_handlers(core, inputs_state->peer->socket, inputs_read, NULL, inputs_state);
+    }
+}
+
+static void inputs_may_write(void *opaque)
+{
+    red_printf("");
+}
+
+static void inputs_link(Channel *channel, RedsStreamContext *peer, int migration,
+                        int num_common_caps, uint32_t *common_caps, int num_caps,
+                        uint32_t *caps)
+{
+    InputsState *inputs_state;
+    int delay_val;
+    int flags;
+
+    red_printf("");
+    ASSERT(channel->data == NULL);
+
+    if (!(inputs_state = malloc(sizeof(InputsState)))) {
+        red_printf("alloc input state failed");
+        close(peer->socket);
+        return;
+    }
+
+    delay_val = 1;
+    if (setsockopt(peer->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    if ((flags = fcntl(peer->socket, F_GETFL)) == -1 ||
+                                            fcntl(peer->socket, F_SETFL, flags | O_ASYNC) == -1) {
+        red_printf("fcntl failed, %s", strerror(errno));
+    }
+
+    memset(inputs_state, 0, sizeof(*inputs_state));
+    inputs_state->peer = peer;
+    inputs_state->end_pos = 0;
+    inputs_state->channel = channel;
+    inputs_state->in_handler.opaque = inputs_state;
+    inputs_state->in_handler.handle_message = inputs_handle_input;
+    inputs_state->out_handler.length = 0;
+    inputs_state->out_handler.opaque = inputs_state;
+    inputs_state->out_handler.select = inputs_select;
+    inputs_state->out_handler.may_write = inputs_may_write;
+    inputs_state->pending_mouse_event = FALSE;
+    channel->data = inputs_state;
+    reds->inputs_state = inputs_state;
+    core->set_file_handlers(core, peer->socket, inputs_read, NULL, inputs_state);
+
+    RedDataHeader header;
+    RedInputsInit inputs_init;
+    header.serial = ++inputs_state->serial;
+    header.type = RED_INPUTS_INIT;
+    header.size = sizeof(RedInputsInit);
+    header.sub_list = 0;
+    inputs_init.keyboard_modifiers = keyboard ? keyboard->get_leds(keyboard) : 0;
+    if (outgoing_write(inputs_state->peer, &inputs_state->out_handler, &header,
+                       sizeof(RedDataHeader)) != OUTGOING_OK ||
+        outgoing_write(inputs_state->peer, &inputs_state->out_handler, &inputs_init,
+                       sizeof(RedInputsInit)) != OUTGOING_OK) {
+        red_printf("failed to send modifiers state");
+        reds_disconnect();
+    }
+}
+
+static void reds_send_keyborad_modifiers(uint8_t modifiers)
+{
+    Channel *channel = reds_find_channel(RED_CHANNEL_INPUTS, 0);
+    InputsState *state;
+
+    if (!channel || !(state = (InputsState *)channel->data)) {
+        return;
+    }
+    ASSERT(state->peer);
+    RedDataHeader header;
+    RedKeyModifiers key_modifiers;
+    header.serial = ++state->serial;
+    header.type = RED_INPUTS_KEY_MODIFAIERS;
+    header.size = sizeof(RedKeyModifiers);
+    header.sub_list = 0;
+    key_modifiers.modifiers = modifiers;
+
+    if (outgoing_write(state->peer, &state->out_handler, &header, sizeof(RedDataHeader))
+                                                                                != OUTGOING_OK ||
+        outgoing_write(state->peer, &state->out_handler, &key_modifiers, sizeof(RedKeyModifiers))
+                                                                                != OUTGOING_OK) {
+        red_printf("failed to send modifiers state");
+        reds_disconnect();
+    }
+}
+
+static void reds_on_keyborad_leads_change(void *opaque, uint8_t leds)
+{
+    reds_send_keyborad_modifiers(leds);
+}
+
+static void openssl_init(RedLinkInfo *link)
+{
+    unsigned long f4 = RSA_F4;
+    link->tiTicketing.bn = BN_new();
+
+    if (!link->tiTicketing.bn) {
+        red_error("OpenSSL BIGNUMS alloc failed");
+    }
+
+    BN_set_word(link->tiTicketing.bn, f4);
+}
+
+static void inputs_init()
+{
+    Channel *channel;
+    if (!(channel = malloc(sizeof(Channel)))) {
+        red_error("alloc inputs chanel failed");
+    }
+    memset(channel, 0, sizeof(Channel));
+    channel->type = RED_CHANNEL_INPUTS;
+    channel->link = inputs_link;
+    channel->shutdown = inputs_shutdown;
+    channel->migrate = inputs_migrate;
+    reds_register_channel(channel);
+}
+
+static void reds_handle_other_links(RedLinkInfo *link)
+{
+    Channel *channel;
+    RedsStreamContext *peer;
+    RedLinkMess *link_mess;
+    uint32_t *caps;
+
+    link_mess = link->link_mess;
+
+    if (!reds->link_id || reds->link_id != link_mess->connection_id) {
+        reds_send_link_result(link, RED_ERR_BAD_CONNECTION_ID);
+        reds_release_link(link);
+        return;
+    }
+
+    if (!(channel = reds_find_channel(link_mess->channel_type,
+                                      link_mess->channel_id))) {
+        reds_send_link_result(link, RED_ERR_CHANNEL_NOT_AVAILABLE);
+        reds_release_link(link);
+        return;
+    }
+
+    reds_send_link_result(link, RED_ERR_OK);
+    reds_show_new_channel(link);
+    if (link_mess->channel_type == RED_CHANNEL_INPUTS && !link->peer->ssl) {
+        SimpleOutItem *item;
+        RedNotify *notify;
+        char *mess = "keybord channel is unsecure";
+        const int mess_len = strlen(mess);
+
+        LOG_MESSAGE(VD_LOG_WARN, "%s", mess);
+
+        if (!(item = new_simple_out_item(RED_NOTIFY, sizeof(RedNotify) + mess_len + 1))) {
+            red_printf("alloc item failed");
+            reds_disconnect();
+            return;
+        }
+
+        notify = (RedNotify *)item->data;
+        notify->time_stamp = get_time_stamp();
+        notify->severty = RED_NOTIFY_SEVERITY_WARN;
+        notify->visibilty = RED_NOTIFY_VISIBILITY_HIGH;
+        notify->what = RED_WARN_GENERAL;
+        notify->message_len = mess_len;
+        memcpy(notify->message, mess, mess_len + 1);
+        reds_push_pipe_item(&item->base);
+    }
+    peer = link->peer;
+    link->link_mess = NULL;
+    __reds_release_link(link);
+    caps = (uint32_t *)((uint8_t *)link_mess + link_mess->caps_offset);
+    channel->link(channel, peer, reds->mig_target, link_mess->num_common_caps,
+                  link_mess->num_common_caps ? caps : NULL, link_mess->num_channel_caps,
+                  link_mess->num_channel_caps ? caps + link_mess->num_common_caps : NULL);
+    free(link_mess);
+}
+
+static void reds_handle_ticket(void *opaque)
+{
+    RedLinkInfo *link = (RedLinkInfo *)opaque;
+    char password[RED_MAX_PASSWORD_LENGTH];
+    time_t ltime;
+
+    //todo: use monotonic time
+    time(&ltime);
+    RSA_private_decrypt(link->tiTicketing.rsa_size,
+                        link->tiTicketing.encrypted_ticket.encrypted_data,
+                        (unsigned char *)password, link->tiTicketing.rsa, RSA_PKCS1_OAEP_PADDING);
+
+    if (ticketing_enabled) {
+        int expired = !link->link_mess->connection_id && taTicket.expiration_time < ltime;
+        char *actual_sever_pass = link->link_mess->connection_id ? reds->taTicket.password :
+                                                                   taTicket.password;
+        if (strlen(actual_sever_pass) == 0) {
+            reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+            red_printf("Ticketing is enabled, but no password is set. "
+                       "please set a ticket first");
+            reds_release_link(link);
+            return;
+        }
+
+        if (expired || strncmp(password, actual_sever_pass, RED_MAX_PASSWORD_LENGTH) != 0) {
+            reds_send_link_result(link, RED_ERR_PERMISSION_DENIED);
+            LOG_MESSAGE(VD_LOG_WARN, "bad connection password or time expired");
+            reds_release_link(link);
+            return;
+        }
+    }
+    if (link->link_mess->channel_type == RED_CHANNEL_MAIN) {
+        reds_handle_main_link(link);
+    } else {
+        reds_handle_other_links(link);
+    }
+}
+
+static inline void async_read_clear_handlers(AsyncRead *obj)
+{
+    if (!obj->active_file_handlers) {
+        return;
+    }
+    obj->active_file_handlers = FALSE;
+    core->set_file_handlers(core, obj->peer->socket, NULL, NULL, NULL);
+}
+
+static void async_read_handler(void *data)
+{
+    AsyncRead *obj = (AsyncRead *)data;
+
+    for (;;) {
+        int n = obj->end - obj->now;
+
+        ASSERT(n > 0);
+        if ((n = obj->peer->cb_read(obj->peer->ctx, obj->now, n)) <= 0) {
+            if (n < 0) {
+                switch (errno) {
+                case EAGAIN:
+                    if (!obj->active_file_handlers) {
+                        obj->active_file_handlers = TRUE;
+                        core->set_file_handlers(core, obj->peer->socket, async_read_handler, NULL,
+                                                obj);
+                    }
+                    return;
+                case EINTR:
+                    break;
+                default:
+                    async_read_clear_handlers(obj);
+                    obj->error(obj->opaque, errno);
+                    return;
+                }
+            } else {
+                async_read_clear_handlers(obj);
+                obj->error(obj->opaque, 0);
+                return;
+            }
+        } else {
+            obj->now += n;
+            if (obj->now == obj->end) {
+                async_read_clear_handlers(obj);
+                obj->done(obj->opaque);
+                return;
+            }
+        }
+    }
+}
+
+static int reds_security_check(RedLinkInfo *link)
+{
+    ChannelSecurityOptions *security_option = find_channel_security(link->link_mess->channel_type);
+    uint32_t security = security_option ? security_option->options : default_channel_security;
+    return (link->peer->ssl && (security & CHANNEL_SECURITY_SSL)) || (!link->peer->ssl &&
+                                                                 (security & CHANNEL_SECURITY_NON));
+}
+
+static void reds_handle_read_link_done(void *opaque)
+{
+    RedLinkInfo *link = (RedLinkInfo *)opaque;
+    RedLinkMess *link_mess = link->link_mess;
+    AsyncRead *obj = &link->asyc_read;
+    uint32_t num_caps = link_mess->num_common_caps + link_mess->num_channel_caps;
+
+    if (num_caps && (num_caps * sizeof(uint32_t) + link_mess->caps_offset >
+                                                   link->link_header.size ||
+                                                     link_mess->caps_offset < sizeof(*link_mess))) {
+        reds_send_link_error(link, RED_ERR_INVALID_DATA);
+        reds_release_link(link);
+        return;
+    }
+
+    if (!reds_security_check(link)) {
+        if (link->peer->ssl) {
+            LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
+                                     "a non secure link", link_mess->channel_type);
+            red_printf("spice channels %d should not be encrypted", link_mess->channel_type);
+            reds_send_link_error(link, RED_ERR_NEED_UNSECURED);
+        } else {
+            LOG_MESSAGE(VD_LOG_INFO, "channels of type %d should connect only over "
+                                     "a secure link", link_mess->channel_type);
+            red_printf("spice channels %d should be encrypted", link_mess->channel_type);
+            reds_send_link_error(link, RED_ERR_NEED_SECURED);
+        }
+        reds_release_link(link);
+        return;
+    }
+
+    if (!reds_send_link_ack(link)) {
+        reds_release_link(link);
+        return;
+    }
+
+    obj->now = (uint8_t *)&link->tiTicketing.encrypted_ticket.encrypted_data;
+    obj->end = obj->now + link->tiTicketing.rsa_size;
+    obj->done = reds_handle_ticket;
+    async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_link_error(void *opaque, int err)
+{
+    RedLinkInfo *link = (RedLinkInfo *)opaque;
+    switch (err) {
+    case 0:
+    case EPIPE:
+        break;
+    default:
+        red_printf("%s", strerror(errno));
+        break;
+    }
+    reds_release_link(link);
+}
+
+static void reds_handle_read_header_done(void *opaque)
+{
+    RedLinkInfo *link = (RedLinkInfo *)opaque;
+    RedLinkHeader *header = &link->link_header;
+    AsyncRead *obj = &link->asyc_read;
+
+    if (header->magic != RED_MAGIC) {
+        reds_send_link_error(link, RED_ERR_INVALID_MAGIC);
+        LOG_MESSAGE(VD_LOG_ERROR, "bad magic %u", header->magic);
+        reds_release_link(link);
+        return;
+    }
+
+    if (header->major_version != RED_VERSION_MAJOR) {
+        if (header->major_version > 0) {
+            reds_send_link_error(link, RED_ERR_VERSION_MISMATCH);
+        }
+        LOG_MESSAGE(VD_LOG_INFO, "version mismatch client %u.%u server %u.%u",
+                    header->major_version,
+                    header->minor_version,
+                    RED_VERSION_MAJOR,
+                    RED_VERSION_MINOR);
+
+        red_printf("version mismatch");
+        reds_release_link(link);
+        return;
+    }
+
+    if (header->size < sizeof(RedLinkMess)) {
+        reds_send_link_error(link, RED_ERR_INVALID_DATA);
+        red_printf("bad size %u", header->size);
+        reds_release_link(link);
+        return;
+    }
+
+    if (!(link->link_mess = malloc(header->size))) {
+        red_printf("malloc failed %u", header->size);
+        reds_release_link(link);
+        return;
+    }
+
+    obj->now = (uint8_t *)link->link_mess;
+    obj->end = obj->now + header->size;
+    obj->done = reds_handle_read_link_done;
+    async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_new_link(RedLinkInfo *link)
+{
+    AsyncRead *obj = &link->asyc_read;
+    obj->opaque = link;
+    obj->peer = link->peer;
+    obj->now = (uint8_t *)&link->link_header;
+    obj->end = (uint8_t *)((RedLinkHeader *)&link->link_header + 1);
+    obj->active_file_handlers = FALSE;
+    obj->done = reds_handle_read_header_done;
+    obj->error = reds_handle_link_error;
+    async_read_handler(&link->asyc_read);
+}
+
+static void reds_handle_ssl_accept(void *data)
+{
+    RedLinkInfo *link = (RedLinkInfo *)data;
+    int return_code;
+
+    if ((return_code = SSL_accept(link->peer->ssl)) != 1) {
+        int ssl_error = SSL_get_error(link->peer->ssl, return_code);
+
+        if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE) {
+            red_printf("SSL_accept failed, error=%d", ssl_error);
+            reds_release_link(link);
+        }
+        return;
+    }
+    reds_handle_new_link(link);
+}
+
+static RedLinkInfo *__reds_accept_connection(int listen_socket)
+{
+    RedLinkInfo *link;
+    RedsStreamContext *peer;
+    int delay_val = 1;
+    int flags;
+    int socket;
+
+    if ((socket = accept(listen_socket, NULL, 0)) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        return NULL;
+    }
+
+    if ((flags = fcntl(socket, F_GETFL)) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    if (fcntl(socket, F_SETFL, flags | O_NONBLOCK) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    if (setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    if (!(link = malloc(sizeof(RedLinkInfo)))) {
+        red_printf("malloc failed");
+        goto error1;
+    }
+
+    if (!(peer = malloc(sizeof(RedsStreamContext)))) {
+        red_printf("malloc failed");
+        goto error2;
+    }
+
+    memset(link, 0, sizeof(RedLinkInfo));
+    memset(peer, 0, sizeof(RedsStreamContext));
+    link->peer = peer;
+    peer->socket = socket;
+    openssl_init(link);
+
+    return link;
+
+error2:
+    free(link);
+
+error1:
+    close(socket);
+
+    return NULL;
+}
+
+static RedLinkInfo *reds_accept_connection(int listen_socket)
+{
+    RedLinkInfo *link;
+    RedsStreamContext *peer;
+
+    if (!(link = __reds_accept_connection(listen_socket))) {
+        return NULL;
+    }
+    peer = link->peer;
+    peer->ctx = (void *)((unsigned long)link->peer->socket);
+    peer->cb_read = (int (*)(void *, void *, int))reds_read;
+    peer->cb_write = (int (*)(void *, void *, int))reds_write;
+    peer->cb_readv = (int (*)(void *, const struct iovec *vector, int count))readv;
+    peer->cb_writev = (int (*)(void *, const struct iovec *vector, int count))writev;
+    peer->cb_free = (int (*)(RedsStreamContext *))reds_free;
+
+    return link;
+}
+
+static void reds_accept_ssl_connection(void *data)
+{
+    RedLinkInfo *link;
+    int return_code;
+    int ssl_error;
+    BIO *sbio;
+
+    link = __reds_accept_connection(reds->secure_listen_socket);
+    if (link == NULL) {
+        return;
+    }
+
+    // Handle SSL handshaking
+    if (!(sbio = BIO_new_socket(link->peer->socket, BIO_NOCLOSE))) {
+        red_printf("could not allocate ssl bio socket");
+        goto error;
+    }
+
+    link->peer->ssl = SSL_new(reds->ctx);
+    if (!link->peer->ssl) {
+        red_printf("could not allocate ssl context");
+        BIO_free(sbio);
+        goto error;
+    }
+
+    SSL_set_bio(link->peer->ssl, sbio, sbio);
+
+    link->peer->ctx = (void *)(link->peer->ssl);
+    link->peer->cb_write = (int (*)(void *, void *, int))reds_ssl_write;
+    link->peer->cb_read = (int (*)(void *, void *, int))reds_ssl_read;
+    link->peer->cb_readv = NULL;
+    link->peer->cb_writev = reds_ssl_writev;
+    link->peer->cb_free = (int (*)(RedsStreamContext *))reds_ssl_free;
+
+    return_code = SSL_accept(link->peer->ssl);
+    if (return_code == 1) {
+        reds_handle_new_link(link);
+        return;
+    }
+
+    ssl_error = SSL_get_error(link->peer->ssl, return_code);
+    if (return_code == -1 && (ssl_error == SSL_ERROR_WANT_READ ||
+                              ssl_error == SSL_ERROR_WANT_WRITE)) {
+        core->set_file_handlers(core, link->peer->socket, reds_handle_ssl_accept,
+                                reds_handle_ssl_accept, link);
+        return;
+    }
+
+    ERR_print_errors_fp(stderr);
+    red_printf("SSL_accept failed, error=%d", ssl_error);
+    SSL_free(link->peer->ssl);
+
+error:
+    close(link->peer->socket);
+    free(link->peer);
+    BN_free(link->tiTicketing.bn);
+    free(link);
+}
+
+static void reds_accept(void *data)
+{
+    RedLinkInfo *link;
+
+    link = reds_accept_connection(reds->listen_socket);
+    if (link == NULL) {
+        red_printf("accept failed");
+        return;
+    }
+    reds_handle_new_link(link);
+}
+
+static int reds_init_socket(uint16_t port)
+{
+    struct sockaddr_in addr;
+    int sock;
+    int flags;
+
+    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
+        red_error("socket failed, %s", strerror(errno));
+    }
+
+    flags = 1;
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &flags, sizeof(flags)) < 0) {
+        red_error("socket set sockopt failed, %s", strerror(errno));
+    }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = spice_addr.s_addr;
+    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
+        red_error("bind failed, %s", strerror(errno));
+    }
+
+    if ((flags = fcntl(sock, F_GETFL)) == -1) {
+        red_error("fcntl get failed, %s", strerror(errno));
+    }
+
+    if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
+        red_error("fcntl set failed, %s", strerror(errno));
+    }
+
+    if (listen(sock, 2) == -1) {
+        red_error("listen failed, %s", strerror(errno));
+    }
+
+    return sock;
+}
+
+static void reds_init_net()
+{
+    if (spice_port != -1) {
+        reds->listen_socket = reds_init_socket(spice_port);
+        if (core->set_file_handlers(core, reds->listen_socket, reds_accept, NULL, NULL)) {
+            red_error("set fd handle failed");
+        }
+    }
+
+    if (spice_secure_port != -1) {
+        reds->secure_listen_socket = reds_init_socket(spice_secure_port);
+        if (core->set_file_handlers(core, reds->secure_listen_socket,
+                                    reds_accept_ssl_connection, NULL, NULL)) {
+            red_error("set fd handle failed");
+        }
+    }
+}
+
+static void load_dh_params(SSL_CTX *ctx, char *file)
+{
+    DH *ret = 0;
+    BIO *bio;
+
+    if ((bio = BIO_new_file(file, "r")) == NULL) {
+        red_error("Could not open DH file");
+    }
+
+    ret = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
+    if (ret == 0) {
+        red_error("Could not read DH params");
+    }
+
+    BIO_free(bio);
+
+    if (SSL_CTX_set_tmp_dh(ctx, ret) < 0) {
+        red_error("Could not set DH params");
+    }
+}
+
+/*The password code is not thread safe*/
+static int ssl_password_cb(char *buf, int size, int flags, void *userdata)
+{
+    char *pass = ssl_parameters.keyfile_password;
+    if (size < strlen(pass) + 1) {
+        return (0);
+    }
+
+    strcpy(buf, pass);
+    return (strlen(pass));
+}
+
+static unsigned long pthreads_thread_id(void)
+{
+    unsigned long ret;
+
+    ret = (unsigned long)pthread_self();
+    return (ret);
+}
+
+static void pthreads_locking_callback(int mode, int type, char *file, int line)
+{
+    if (mode & CRYPTO_LOCK) {
+        pthread_mutex_lock(&(lock_cs[type]));
+        lock_count[type]++;
+    } else {
+        pthread_mutex_unlock(&(lock_cs[type]));
+    }
+}
+
+static void openssl_thread_setup()
+{
+    int i;
+
+    lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(pthread_mutex_t));
+    lock_count = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(long));
+
+    for (i = 0; i < CRYPTO_num_locks(); i++) {
+        lock_count[i] = 0;
+        pthread_mutex_init(&(lock_cs[i]), NULL);
+    }
+
+    CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
+    CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
+}
+
+static void reds_init_ssl()
+{
+    SSL_METHOD *ssl_method;
+    int return_code;
+    long ssl_options = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
+
+    /* Global system initialization*/
+    SSL_library_init();
+    SSL_load_error_strings();
+
+    /* Create our context*/
+    ssl_method = TLSv1_method();
+    reds->ctx = SSL_CTX_new(ssl_method);
+    if (!reds->ctx) {
+        red_error("Could not allocate new SSL context");
+    }
+
+    /* Limit connection to TLSv1 only */
+#ifdef SSL_OP_NO_COMPRESSION
+    ssl_options |= SSL_OP_NO_COMPRESSION;
+#endif
+    SSL_CTX_set_options(reds->ctx, ssl_options);
+
+    /* Load our keys and certificates*/
+    return_code = SSL_CTX_use_certificate_chain_file(reds->ctx, ssl_parameters.certs_file);
+    if (return_code != 1) {
+        red_error("Could not load certificates from %s", ssl_parameters.certs_file);
+    }
+
+    SSL_CTX_set_default_passwd_cb(reds->ctx, ssl_password_cb);
+
+    return_code = SSL_CTX_use_PrivateKey_file(reds->ctx, ssl_parameters.private_key_file,
+                                              SSL_FILETYPE_PEM);
+    if (return_code != 1) {
+        red_error("Could not user private key file");
+    }
+
+    /* Load the CAs we trust*/
+    return_code = SSL_CTX_load_verify_locations(reds->ctx, ssl_parameters.ca_certificate_file, 0);
+    if (return_code != 1) {
+        red_error("Could not use ca file");
+    }
+
+#if (OPENSSL_VERSION_NUMBER < 0x00905100L)
+    SSL_CTX_set_verify_depth(reds->ctx, 1);
+#endif
+
+    load_dh_params(reds->ctx, ssl_parameters.dh_key_file);
+
+    SSL_CTX_set_session_id_context(reds->ctx, (const unsigned char *)"SPICE", 5);
+    SSL_CTX_set_cipher_list(reds->ctx, ssl_parameters.ciphersuite);
+
+    openssl_thread_setup();
+
+#ifndef SSL_OP_NO_COMPRESSION
+    STACK *cmp_stack = SSL_COMP_get_compression_methods();
+    sk_zero(cmp_stack);
+#endif
+}
+
+static void reds_exit()
+{
+    if (reds->peer) {
+        close(reds->peer->socket);
+    }
+#ifdef RED_STATISTICS
+    shm_unlink(reds->stat_shm_name);
+    free(reds->stat_shm_name);
+#endif
+    unsetenv("QEMU_AUDIO_DRV");
+}
+
+enum {
+    SPICE_OPTION_INVALID,
+    SPICE_OPTION_PORT,
+    SPICE_OPTION_SPORT,
+    SPICE_OPTION_HOST,
+    SPICE_OPTION_IMAGE_COMPRESSION,
+    SPICE_OPTION_PASSWORD,
+    SPICE_OPTION_DISABLE_TICKET,
+    SPICE_OPTION_RENDERER,
+    SPICE_OPTION_SSLKEY,
+    SPICE_OPTION_SSLCERTS,
+    SPICE_OPTION_SSLCAFILE,
+    SPICE_OPTION_SSLDHFILE,
+    SPICE_OPTION_SSLPASSWORD,
+    SPICE_OPTION_SSLCIPHERSUITE,
+    SPICE_SECURED_CHANNELS,
+    SPICE_UNSECURED_CHANNELS,
+    SPICE_OPTION_STREAMING_VIDEO,
+    SPICE_OPTION_AGENT_MOUSE,
+    SPICE_OPTION_PLAYBACK_COMPRESSION,
+};
+
+typedef struct OptionsMap {
+    const char *name;
+    int val;
+} OptionsMap;
+
+static int find_option(const char *str, OptionsMap *options_map)
+{
+    int i = 0;
+
+    for (i = 0; options_map[i].name != NULL; i++) {
+        if (strcmp(str, options_map[i].name) == 0) {
+            return options_map[i].val;
+        }
+    }
+    return SPICE_OPTION_INVALID;
+}
+
+static void clear_blanks(char **ptr)
+{
+    char *str = *ptr;
+    while (isspace(*str)) {
+        str++;
+    }
+    while (isspace(str[strlen(str) - 1])) {
+        str[strlen(str) - 1] = 0;
+    }
+    *ptr = str;
+}
+
+static int get_option(char **args, char **out_val, OptionsMap *map, char seperator)
+{
+    char *p;
+    char *next;
+    char *val;
+
+    ASSERT(args && out_val);
+
+    p = *args;
+    if ((next = strchr(p, seperator))) {
+        *next = 0;
+        *args = next + 1;
+    } else {
+        *args = NULL;
+    }
+
+    if ((val = strchr(p, '='))) {
+        *(val++) = 0;
+        clear_blanks(&val);
+        *out_val = (strlen(val) == 0) ? NULL : val;
+    } else {
+        *out_val = NULL;
+    }
+
+    clear_blanks(&p);
+    return find_option(p, map);
+}
+
+enum {
+    SPICE_TICKET_OPTION_INVALID,
+    SPICE_TICKET_OPTION_EXPIRATION,
+    SPICE_TICKET_OPTION_CONNECTED,
+};
+
+static OptionsMap _spice_ticket_options[] = {
+    {"expiration", SPICE_TICKET_OPTION_EXPIRATION},
+    {"connected", SPICE_TICKET_OPTION_CONNECTED},
+    {NULL, 0},
+};
+
+static inline void on_activating_ticketing()
+{
+    if (!ticketing_enabled && reds->peer) {
+        red_printf("disconnecting");
+        reds_disconnect();
+    }
+}
+
+static void reds_reset_ticketing()
+{
+    on_activating_ticketing();
+    ticketing_enabled = 1;
+    taTicket.expiration_time = 0;
+    memset(taTicket.password, 0, sizeof(taTicket.password));
+}
+
+static void reds_set_ticketing(const char *pass, long expiration)
+{
+    ASSERT(expiration >= 0);
+    on_activating_ticketing();
+    ticketing_enabled = 1;
+    if (expiration == 0) {
+        taTicket.expiration_time = INT_MAX;
+    } else {
+        time_t ltime;
+
+        time(&ltime);
+        taTicket.expiration_time = ltime + expiration;
+    }
+    strncpy(taTicket.password, pass, sizeof(taTicket.password));
+}
+
+static void reds_do_set_ticket(const char *password, const char *args)
+{
+    long expiration = 0;
+    char *local_args = NULL;
+    const char *term_str = "invalid args";
+    int disconnect = FALSE;
+    int fail = FALSE;
+
+    if (!password) {
+        term_str = "unexpected NULL password";
+        goto error;
+    }
+
+    if (args) {
+        char *in_args;
+        int option;
+        char *val;
+
+        in_args = local_args = malloc(strlen(args) + 1);
+        strcpy(local_args, args);
+        do {
+            switch (option = get_option(&in_args, &val, _spice_ticket_options, ',')) {
+            case SPICE_TICKET_OPTION_EXPIRATION: {
+                char *endptr;
+
+                if (!val) {
+                    goto error;
+                }
+                expiration = strtol(val, &endptr, 0);
+                if (endptr != val + strlen(val) || expiration < 0) {
+                    term_str = "invalid expiration";
+                    goto error;
+                }
+                break;
+            }
+            case SPICE_TICKET_OPTION_CONNECTED:
+                if (!val) {
+                    goto error;
+                }
+
+                if (strcmp(val, "disconnect") == 0) {
+                    disconnect = TRUE;
+                    fail = FALSE;
+                } else if (strcmp(val, "fail") == 0) {
+                    fail = TRUE;
+                    disconnect = FALSE;
+                } else if (strcmp(val, "keep") == 0) {
+                    fail = FALSE;
+                    disconnect = FALSE;
+                } else {
+                    goto error;
+                }
+                break;
+            default:
+                goto error;
+            }
+        } while (in_args);
+    }
+
+    if (fail && reds->peer) {
+        term_str = "Ticket set failed";
+    } else {
+        if (disconnect) {
+            reds_disconnect();
+        }
+        reds_set_ticketing(password, expiration);
+        term_str = "Ticket set successfully";
+    }
+    core->term_printf(core, "%s\n", term_str);
+    free(local_args);
+    return;
+
+error:
+    reds_reset_ticketing();
+    core->term_printf(core, "%s\n", term_str);
+    free(local_args);
+}
+
+static void reds_do_set_ticket64(const char *password64, const char *args)
+{
+    char *password;
+
+    if (!password64) {
+        reds_reset_ticketing();
+        core->term_printf(core, "unexpected NULL password\n");
+        return;
+    }
+
+    if (!(password = base64decode(password64, strlen(password64)))) {
+        reds_reset_ticketing();
+        core->term_printf(core, "set_ticket64 failed!\n");
+        return;
+    }
+    reds_do_set_ticket(password, args);
+    free(password);
+}
+
+static void reds_do_info_spice()
+{
+    core->term_printf(core, "spice info:");
+    if (reds->peer) {
+        char *ip = NULL;
+        struct sockaddr_in sock_addr;
+        socklen_t len = sizeof(sock_addr);
+        if (getpeername(reds->peer->socket, (struct sockaddr *)&sock_addr, &len) != -1) {
+            ip = inet_ntoa(sock_addr.sin_addr);
+        }
+        core->term_printf(core, " client=%s", ip);
+    } else {
+        core->term_printf(core, " disconnected");
+    }
+    core->term_printf(core, " ticketing=%s", ticketing_enabled ? "on" : "off");
+    switch (image_compression) {
+    case IMAGE_COMPRESS_AUTO_GLZ:
+        core->term_printf(core, " ic=auto_glz");
+        break;
+    case IMAGE_COMPRESS_AUTO_LZ:
+        core->term_printf(core, " ic=auto_lz");
+        break;
+    case IMAGE_COMPRESS_QUIC:
+        core->term_printf(core, " ic=quic");
+        break;
+    case IMAGE_COMPRESS_LZ:
+        core->term_printf(core, " ic=lz");
+        break;
+    case IMAGE_COMPRESS_GLZ:
+        core->term_printf(core, " ic=glz");
+        break;
+    case IMAGE_COMPRESS_OFF:
+        core->term_printf(core, " ic=off");
+        break;
+    case IMAGE_COMPRESS_INVALID:
+    default:
+        core->term_printf(core, " ic=invalid");
+    }
+
+    core->term_printf(core, " sv=%s", streaming_video ? "on" : "off");
+    core->term_printf(core, " playback-compression=%s\n",
+                      snd_get_playback_compression() ? "on" : "off");
+}
+
+static void set_image_compression(image_compression_t val)
+{
+    if (val == image_compression) {
+        return;
+    }
+    image_compression = val;
+    red_dispatcher_on_ic_change();
+}
+
+static image_compression_t reds_get_image_compression(const char *val)
+{
+    if ((strcmp(val, "on") == 0) || (strcmp(val, "auto_glz") == 0)) {
+        return IMAGE_COMPRESS_AUTO_GLZ;
+    } else if (strcmp(val, "auto_lz") == 0) {
+        return IMAGE_COMPRESS_AUTO_LZ;
+    } else if (strcmp(val, "quic") == 0) {
+        return IMAGE_COMPRESS_QUIC;
+    } else if (strcmp(val, "glz") == 0) {
+        return IMAGE_COMPRESS_GLZ;
+    } else if (strcmp(val, "lz") == 0) {
+        return IMAGE_COMPRESS_LZ;
+    } else if (strcmp(val, "off") == 0) {
+        return IMAGE_COMPRESS_OFF;
+    }
+    return IMAGE_COMPRESS_INVALID;
+}
+
+static void reds_do_set_image_compression(const char *val)
+{
+    image_compression_t real_val = reds_get_image_compression(val);
+    if (real_val == IMAGE_COMPRESS_INVALID) {
+        core->term_printf(core, "bad image compression arg\n");
+        return;
+    }
+    set_image_compression(real_val);
+}
+
+static void reds_do_set_streaming_video(const char *val)
+{
+    uint32_t new_val;
+    if (strcmp(val, "on") == 0) {
+        new_val = TRUE;
+    } else if (strcmp(val, "off") == 0) {
+        new_val = FALSE;
+    } else {
+        core->term_printf(core, "bad streaming video arg\n");
+        return;
+    }
+    if (new_val == streaming_video) {
+        return;
+    }
+    streaming_video = new_val;
+    red_dispatcher_on_sv_change();
+}
+
+static void reds_do_set_agent_mouse(const char *val)
+{
+    int new_val;
+    if (strcmp(val, "on") == 0) {
+        new_val = TRUE;
+    } else if (strcmp(val, "off") == 0) {
+        new_val = FALSE;
+    } else {
+        core->term_printf(core, "bad agent mouse arg\n");
+        return;
+    }
+    if (new_val == agent_mouse) {
+        return;
+    }
+    agent_mouse = new_val;
+    reds_update_mouse_mode();
+}
+
+static void reds_do_set_playback_compression(const char *val)
+{
+    int on;
+    if (strcmp(val, "on") == 0) {
+        on = TRUE;
+    } else if (strcmp(val, "off") == 0) {
+        on = FALSE;
+    } else {
+        core->term_printf(core, "bad playback compression arg\n");
+        return;
+    }
+    snd_set_playback_compression(on);
+}
+
+static OptionsMap _spice_options[] = {
+    {"port", SPICE_OPTION_PORT},
+    {"sport", SPICE_OPTION_SPORT},
+    {"host", SPICE_OPTION_HOST},
+    {"ic", SPICE_OPTION_IMAGE_COMPRESSION},
+    {"password", SPICE_OPTION_PASSWORD},
+    {"disable-ticketing", SPICE_OPTION_DISABLE_TICKET},
+    {"renderer", SPICE_OPTION_RENDERER},
+    {"sslkey", SPICE_OPTION_SSLKEY},
+    {"sslcert", SPICE_OPTION_SSLCERTS},
+    {"sslcafile", SPICE_OPTION_SSLCAFILE},
+    {"ssldhfile", SPICE_OPTION_SSLDHFILE},
+    {"sslpassword", SPICE_OPTION_SSLPASSWORD},
+    {"sslciphersuite", SPICE_OPTION_SSLCIPHERSUITE},
+    {"secure-channels", SPICE_SECURED_CHANNELS},
+    {"unsecure-channels", SPICE_UNSECURED_CHANNELS},
+    {"sv", SPICE_OPTION_STREAMING_VIDEO},
+    {"agent-mouse", SPICE_OPTION_AGENT_MOUSE},
+    {"playback-compression", SPICE_OPTION_PLAYBACK_COMPRESSION},
+    {NULL, 0},
+};
+
+enum {
+    CHANNEL_NAME_INVALID,
+    CHANNEL_NAME_ALL,
+    CHANNEL_NAME_MAIN,
+    CHANNEL_NAME_DISPLAY,
+    CHANNEL_NAME_INPUTS,
+    CHANNEL_NAME_CURSOR,
+    CHANNEL_NAME_PLAYBACK,
+    CHANNEL_NAME_RECORD,
+};
+
+static OptionsMap _channel_map[] = {
+    {"all", CHANNEL_NAME_ALL},
+    {"main", CHANNEL_NAME_MAIN},
+    {"display", CHANNEL_NAME_DISPLAY},
+    {"inputs", CHANNEL_NAME_INPUTS},
+    {"cursor", CHANNEL_NAME_CURSOR},
+    {"playback", CHANNEL_NAME_PLAYBACK},
+    {"record", CHANNEL_NAME_RECORD},
+    {NULL, 0},
+};
+
+static void set_all_channels_security(uint32_t security)
+{
+    while (channels_security) {
+        ChannelSecurityOptions *temp = channels_security;
+        channels_security = channels_security->next;
+        free(temp);
+    }
+    default_channel_security = security;
+}
+
+static void set_one_channel_security(int id, uint32_t security)
+{
+    ChannelSecurityOptions *security_options;
+
+    if ((security_options = find_channel_security(id))) {
+        security_options->options = security;
+        return;
+    }
+    security_options = (ChannelSecurityOptions *)malloc(sizeof(*security_options));
+    if (!security_options) {
+        red_error("malloc failed");
+    }
+    security_options->channel_id = id;
+    security_options->options = security;
+    security_options->next = channels_security;
+    channels_security = security_options;
+}
+
+static int set_channels_security(const char *channels, uint32_t security)
+{
+    char *local_str = malloc(strlen(channels) + 1);
+    int channel_name;
+    char *str;
+    char *val;
+    int all = 0;
+    int specific = 0;
+
+    if (!local_str) {
+        red_error("malloc failed");
+    }
+    strcpy(local_str, channels);
+    str = local_str;
+    do {
+        switch (channel_name = get_option(&str, &val, _channel_map, '+')) {
+        case CHANNEL_NAME_ALL:
+            all++;
+            break;
+        case CHANNEL_NAME_MAIN:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_MAIN, security);
+            break;
+        case CHANNEL_NAME_DISPLAY:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_DISPLAY, security);
+            break;
+        case CHANNEL_NAME_INPUTS:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_INPUTS, security);
+            break;
+        case CHANNEL_NAME_CURSOR:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_CURSOR, security);
+            break;
+        case CHANNEL_NAME_PLAYBACK:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_PLAYBACK, security);
+            break;
+        case CHANNEL_NAME_RECORD:
+            specific++;
+            set_one_channel_security(RED_CHANNEL_RECORD, security);
+            break;
+        default:
+            goto error;
+        }
+        if (val) {
+            goto error;
+        }
+    } while (str);
+
+    if (all) {
+        if (specific || all > 1) {
+            goto error;
+        }
+        set_all_channels_security(security);
+        return TRUE;
+    }
+    return TRUE;
+
+error:
+    free(local_str);
+    return FALSE;
+}
+
+int __attribute__ ((visibility ("default"))) spice_parse_args(const char *in_args)
+{
+    char *local_args;
+    char *args;
+    int option;
+    char *val;
+    int renderers_opt = FALSE;
+
+    int ssl_port = FALSE;
+    int ssl_key = FALSE;
+    int ssl_certs = FALSE;
+    int ssl_ciphersuite = FALSE;
+    int ssl_cafile = FALSE;
+    int ssl_dhfile = FALSE;
+
+    memset(&ssl_parameters, 0, sizeof(ssl_parameters));
+
+    local_args = malloc(strlen(in_args) + 1);
+    strcpy(local_args, in_args);
+
+    args = local_args;
+    do {
+        switch (option = get_option(&args, &val, _spice_options, ',')) {
+        case SPICE_OPTION_PORT: {
+            char *endptr;
+            long int port;
+
+            if (!val) {
+                goto error;
+            }
+            port = strtol(val, &endptr, 0);
+            if (endptr != val + strlen(val) || port < 0 || port > 0xffff) {
+                goto error;
+            }
+            spice_port = port;
+            break;
+        }
+        case SPICE_OPTION_SPORT: {
+            char *endptr;
+            long int port;
+
+            if (!val) {
+                goto error;
+            }
+            port = strtol(val, &endptr, 0);
+            if (endptr != val + strlen(val) || port < 0 || port > 0xffff) {
+                goto error;
+            }
+
+            ssl_port = TRUE;
+            spice_secure_port = port;
+            break;
+        }
+        case SPICE_OPTION_HOST: {
+            struct hostent* host_addr;
+            if (!val) {
+                goto error;
+            }
+            if ((host_addr = gethostbyname(val)) == NULL || host_addr->h_addrtype != AF_INET) {
+                goto error;
+            }
+            ASSERT(host_addr->h_length == sizeof(spice_addr));
+            memcpy(&spice_addr, host_addr->h_addr, sizeof(spice_addr));
+            break;
+        }
+        case SPICE_OPTION_IMAGE_COMPRESSION:
+            if (!val) {
+                goto error;
+            }
+            image_compression = reds_get_image_compression(val);
+            if (image_compression == IMAGE_COMPRESS_INVALID) {
+                goto error;
+            }
+            break;
+        case SPICE_OPTION_PASSWORD:
+            ticketing_enabled = 1;
+
+            if (val) {
+                strncpy(taTicket.password, val, sizeof taTicket.password);
+                //todo: add expiration option
+                taTicket.expiration_time = INT_MAX;
+            }
+
+            break;
+        case SPICE_OPTION_DISABLE_TICKET:
+            ticketing_enabled = 0;
+            break;
+        case SPICE_OPTION_RENDERER:
+            renderers_opt = TRUE;
+            if (!val) {
+                goto error;
+            }
+            while (val) {
+                char *now = val;
+                if ((val = strchr(now, '+'))) {
+                    *val++ = 0;
+                }
+                if (!red_dispatcher_add_renderer(now)) {
+                    goto error;
+                }
+            }
+
+            break;
+        case SPICE_OPTION_SSLCIPHERSUITE:
+            ssl_ciphersuite = TRUE;
+
+            if (val) {
+                strncpy(ssl_parameters.ciphersuite, val, sizeof(ssl_parameters.ciphersuite));
+            }
+
+            break;
+        case SPICE_OPTION_SSLPASSWORD:
+            if (val) {
+                strncpy(ssl_parameters.keyfile_password, val,
+                        sizeof(ssl_parameters.keyfile_password));
+            }
+            break;
+        case SPICE_OPTION_SSLKEY:
+            ssl_key = TRUE;
+
+            if (val) {
+                strncpy(ssl_parameters.private_key_file, val,
+                        sizeof(ssl_parameters.private_key_file));
+            }
+            break;
+        case SPICE_OPTION_SSLCERTS:
+            ssl_certs = TRUE;
+
+            if (val) {
+                strncpy(ssl_parameters.certs_file, val, sizeof(ssl_parameters.certs_file));
+            }
+            break;
+        case SPICE_OPTION_SSLCAFILE:
+            ssl_cafile = TRUE;
+
+            if (val) {
+                strncpy(ssl_parameters.ca_certificate_file, val,
+                        sizeof(ssl_parameters.ca_certificate_file));
+            }
+            break;
+        case SPICE_OPTION_SSLDHFILE:
+            ssl_dhfile = TRUE;
+
+            if (val) {
+                strncpy(ssl_parameters.dh_key_file, val, sizeof(ssl_parameters.dh_key_file));
+            }
+            break;
+        case SPICE_SECURED_CHANNELS:
+            if (!val || !set_channels_security(val, CHANNEL_SECURITY_SSL)) {
+                goto error;
+            }
+            break;
+        case SPICE_UNSECURED_CHANNELS:
+            if (!val || !set_channels_security(val, CHANNEL_SECURITY_NON)) {
+                goto error;
+            }
+            break;
+        case SPICE_OPTION_STREAMING_VIDEO:
+            if (!val) {
+                goto error;
+            }
+            if (strcmp(val, "off") == 0) {
+                streaming_video = FALSE;
+            } else if (strcmp(val, "on") != 0) {
+                goto error;
+            }
+            break;
+        case SPICE_OPTION_PLAYBACK_COMPRESSION:
+            if (!val) {
+                goto error;
+            }
+            if (strcmp(val, "on") == 0) {
+                snd_set_playback_compression(TRUE);
+            } else if (strcmp(val, "off") == 0) {
+                snd_set_playback_compression(FALSE);
+            } else {
+                goto error;
+            }
+            break;
+        case SPICE_OPTION_AGENT_MOUSE:
+            if (!val) {
+                goto error;
+            }
+            if (strcmp(val, "on") == 0) {
+                agent_mouse = TRUE;
+            } else if (strcmp(val, "off") == 0) {
+                agent_mouse = FALSE;
+            } else {
+                goto error;
+            }
+            break;
+        default:
+            goto error;
+        }
+    } while (args);
+
+    if (!renderers_opt && !red_dispatcher_add_renderer("cairo")) {
+        goto error;
+    }
+
+    // All SSL parameters should be either on or off.
+    if (ssl_port != ssl_key || ssl_key != ssl_certs || ssl_certs != ssl_cafile ||
+        ssl_cafile != ssl_dhfile || ssl_dhfile != ssl_ciphersuite) {
+
+        goto error;
+    }
+    free(local_args);
+    return TRUE;
+
+error:
+    free(local_args);
+    return FALSE;
+}
+
+const char *spice_usage_str[] __attribute__ ((visibility ("default"))) = {
+    "[port=<port>][,sport=<port>][,host=<host>]",
+    "[,ic=on|auto_glz|auto_lz|quic|glz|lz|off]",
+    "[,playback-compression=on|off]",
+    "[,password=password][,disable-ticketing]",
+    "[,renderer=oglpbuf+oglpixmap+cairo]",
+    "[,sslkeys=key directory,sslcerts=certs directory,sslpassword=pem password,",
+    "                                              sslciphersuite=cipher suite]",
+    "[,secure-channels=all|channel+channel+...]",
+    "[,unsecure-channels=all|channel+channel+...]",
+    "[,vs=on|off] [,ac=on|off]",
+    "    listen on interface address <host> port <port> and/or sport <port>",
+    "    setting ticket password using \"ticket\" option",
+    "    setting image compression using \"ic\" option [default=auto_local]",
+    "    setting playback compression using \"playback-compression\" option [default=on]",
+    "    select renderers using \"renderer\" option",
+    "    sslkeys - set directory where ssl key file resides.",
+    "    sslcerts - set directory where ssl cert file resides.",
+    "    sslpassword - set the password to open the private key file.",
+    "    sslciphersuite - set the cipher suite to use.",
+    "    setting streaming video using \"sv\" option [default=on]",
+    "    setting audio compression codec using \"ac\" option [default=off]",
+    "    secure-channels - force secure connection on all/specific chnnels.",
+    "                       channels names: main, inputs, display, cursor,",
+    "                                       playback and record.",
+    "    unsecure-channels - force unsecure connection on all/specific chnnels.",
+    "                         channels names as in secure-channels.",
+    NULL,
+};
+
+#define REDS_SAVE_VERSION 1
+
+static OptionsMap spice_mig_options[] = {
+    {"spicesport", SPICE_OPTION_SPORT},
+    {"spiceport", SPICE_OPTION_PORT},
+    {"spicehost", SPICE_OPTION_HOST},
+    {NULL, 0},
+};
+
+struct RedsMigSpice;
+
+typedef struct RedsMigRead {
+    uint8_t buf[RECIVE_BUF_SIZE];
+    uint32_t end_pos;
+    uint32_t size;
+
+    void (*handle_data)(struct RedsMigSpice *message);
+} RedsMigRead;
+
+typedef struct RedsMigWrite {
+    uint8_t buf[SEND_BUF_SIZE];
+    uint8_t *now;
+    uint32_t length;
+
+    void (*handle_done)(struct RedsMigSpice *s);
+} RedsMigWrite;
+
+typedef struct RedsMigSpice {
+    int fd;
+    RedsMigWrite write;
+    RedsMigRead read;
+
+    char pub_key[RED_TICKET_PUBKEY_BYTES];
+    uint32_t mig_key;
+
+    char *local_args;
+    char *host;
+    int port;
+    int sport;
+} RedsMigSpice;
+
+typedef struct RedsMigSpiceMessage {
+    uint32_t link_id;
+} RedsMigSpiceMessage;
+
+static int reds_mig_actual_read(RedsMigSpice *s)
+{
+    for (;;) {
+        uint8_t *buf = s->read.buf;
+        uint32_t pos = s->read.end_pos;
+        int n;
+        n = read(s->fd, buf + pos, s->read.size - pos);
+        if (n <= 0) {
+            if (n == 0) {
+                return -1;
+            }
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+            case EINTR:
+                break;
+            case EPIPE:
+                return -1;
+            default:
+                red_printf("%s", strerror(errno));
+                return -1;
+            }
+        } else {
+            s->read.end_pos += n;
+            if (s->read.end_pos == s->read.size) {
+                s->read.handle_data(s);
+                return 0;
+            }
+        }
+    }
+}
+
+static int reds_mig_actual_write(RedsMigSpice *s)
+{
+    if (!s->write.length) {
+        return 0;
+    }
+
+    while (s->write.length) {
+        int n;
+
+        n = write(s->fd, s->write.now, s->write.length);
+        if (n <= 0) {
+            if (n == 0) {
+                return -1;
+            }
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+            case EINTR:
+                break;
+            case EPIPE:
+                return -1;
+            default:
+                red_printf("%s", strerror(errno));
+                return -1;
+            }
+        } else {
+            s->write.now += n;
+            s->write.length -= n;
+        }
+    }
+
+    s->write.handle_done(s);
+    return 0;
+}
+
+static void reds_mig_failed(RedsMigSpice *s)
+{
+    red_printf("");
+    core->set_file_handlers(core, s->fd, NULL, NULL, NULL);
+    if (s->local_args) {
+        free(s->local_args);
+    }
+    free(s);
+
+    reds_mig_disconnect();
+}
+
+static void reds_mig_write(void *data)
+{
+    RedsMigSpice *s = data;
+
+    if (reds_mig_actual_write((RedsMigSpice *)data)) {
+        red_printf("write error cannot continue spice migration");
+        reds_mig_failed(s);
+    }
+}
+
+static void reds_mig_read(void *data)
+{
+    RedsMigSpice *s = data;
+
+    if (reds_mig_actual_read((RedsMigSpice *)data)) {
+        red_printf("read error cannot continue spice migration");
+        reds_mig_failed(s);
+    }
+}
+
+static void reds_mig_continue(RedsMigSpice *s)
+{
+    RedMigrationBegin *migrate;
+    SimpleOutItem *item;
+    int host_len;
+
+    red_printf("");
+    core->set_file_handlers(core, s->fd, NULL, NULL, NULL);
+    host_len = strlen(s->host) + 1;
+    if (!(item = new_simple_out_item(RED_MIGRATE_BEGIN, sizeof(RedMigrationBegin) + host_len))) {
+        red_printf("alloc item failed");
+        reds_disconnect();
+        return;
+    }
+    migrate = (RedMigrationBegin *)item->data;
+    migrate->port = s->port;
+    migrate->sport = s->sport;
+    memcpy(migrate->host, s->host, host_len);
+    reds_push_pipe_item(&item->base);
+
+    free(s->local_args);
+    free(s);
+    reds->mig_wait_connect = TRUE;
+    core->arm_timer(core, reds->mig_timer, MIGRATE_TIMEOUT);
+}
+
+static void reds_mig_receive_ack(RedsMigSpice *s)
+{
+    s->read.size = sizeof(uint32_t);
+    s->read.end_pos = 0;
+    s->read.handle_data = reds_mig_continue;
+
+    core->set_file_handlers(core, s->fd, reds_mig_read, NULL, s);
+}
+
+static void reds_mig_send_link_id(RedsMigSpice *s)
+{
+    RedsMigSpiceMessage *data = (RedsMigSpiceMessage *)s->write.buf;
+
+    memcpy(&data->link_id, &reds->link_id, sizeof(reds->link_id));
+
+    s->write.now = s->write.buf;
+    s->write.length = sizeof(RedsMigSpiceMessage);
+    s->write.handle_done = reds_mig_receive_ack;
+
+    core->set_file_handlers(core, s->fd, reds_mig_write, reds_mig_write, s);
+}
+
+static void reds_mig_send_ticket(RedsMigSpice *s)
+{
+    EVP_PKEY *pubkey = NULL;
+    BIO *bio_key;
+    RSA *rsa;
+    int rsa_size = 0;
+
+    red_printf("");
+
+    bio_key = BIO_new(BIO_s_mem());
+    if (bio_key != NULL) {
+        BIO_write(bio_key, s->read.buf, RED_TICKET_PUBKEY_BYTES);
+        pubkey = d2i_PUBKEY_bio(bio_key, NULL);
+        rsa = pubkey->pkey.rsa;
+        rsa_size = RSA_size(rsa);
+        if (RSA_public_encrypt(strlen(reds->taTicket.password) + 1,
+                               (unsigned char *)reds->taTicket.password,
+                               (uint8_t *)(s->write.buf),
+                               rsa, RSA_PKCS1_OAEP_PADDING) > 0) {
+            s->write.length = RSA_size(rsa);
+            s->write.now = s->write.buf;
+            s->write.handle_done = reds_mig_send_link_id;
+            core->set_file_handlers(core, s->fd, reds_mig_write, reds_mig_write, s);
+        } else {
+            reds_mig_failed(s);
+        }
+    } else {
+        reds_mig_failed(s);
+    }
+
+    EVP_PKEY_free(pubkey);
+    BIO_free(bio_key);
+}
+
+static void reds_mig_control(RedsMigSpice *spice_migration)
+{
+    uint32_t *control;
+
+    core->set_file_handlers(core, spice_migration->fd, NULL, NULL, NULL);
+    control = (uint32_t *)spice_migration->read.buf;
+
+    switch (*control) {
+    case REDS_MIG_CONTINUE:
+        spice_migration->read.size = RED_TICKET_PUBKEY_BYTES;
+        spice_migration->read.end_pos = 0;
+        spice_migration->read.handle_data = reds_mig_send_ticket;
+
+        core->set_file_handlers(core, spice_migration->fd, reds_mig_read,
+                                NULL, spice_migration);
+        break;
+    case REDS_MIG_ABORT:
+        red_printf("abort");
+        reds_mig_failed(spice_migration);
+        break;
+    default:
+        red_printf("invalid control");
+        reds_mig_failed(spice_migration);
+    }
+}
+
+static void reds_mig_receive_control(RedsMigSpice *spice_migration)
+{
+    spice_migration->read.size = sizeof(uint32_t);
+    spice_migration->read.end_pos = 0;
+    spice_migration->read.handle_data = reds_mig_control;
+
+    core->set_file_handlers(core, spice_migration->fd, reds_mig_read, NULL, spice_migration);
+}
+
+static void reds_mig_started(void *opaque, const char *in_args)
+{
+    RedsMigSpice *spice_migration = NULL;
+    uint32_t *version;
+    char *val;
+    char *args;
+    int option;
+
+    ASSERT(in_args);
+    red_printf("");
+
+    reds->mig_inprogress = TRUE;
+
+    if (reds->listen_socket != -1) {
+        core->set_file_handlers(core, reds->listen_socket, NULL, NULL, NULL);
+    }
+
+    if (reds->secure_listen_socket != -1) {
+        core->set_file_handlers(core, reds->secure_listen_socket, NULL, NULL, NULL);
+    }
+
+    if (reds->peer == NULL) {
+        red_printf("not connected to peer");
+        goto error;
+    }
+
+    spice_migration = (RedsMigSpice *)malloc(sizeof(RedsMigSpice));
+    if (!spice_migration) {
+        red_printf("Could not allocate memory for spice migration structure");
+        goto error;
+    }
+    memset(spice_migration, 0, sizeof(RedsMigSpice));
+    spice_migration->port = -1;
+    spice_migration->sport = -1;
+
+    if (!(spice_migration->local_args = malloc(strlen(in_args) + 1))) {
+        red_printf("str malloc failed");
+        goto error;
+    }
+
+    strcpy(spice_migration->local_args, in_args);
+    args = spice_migration->local_args;
+    do {
+        switch (option = get_option(&args, &val, spice_mig_options, ',')) {
+        case SPICE_OPTION_SPORT: {
+            char *endptr;
+
+            if (!val) {
+                goto error;
+            }
+            spice_migration->sport = strtol(val, &endptr, 0);
+            if (endptr != val + strlen(val) || spice_migration->sport < 0 ||
+                                                                  spice_migration->sport > 0xffff) {
+                goto error;
+            }
+            break;
+        }
+        case SPICE_OPTION_PORT: {
+            char *endptr;
+
+            if (!val) {
+                goto error;
+            }
+            spice_migration->port = strtol(val, &endptr, 0);
+            if (
+                endptr != val + strlen(val) ||
+                spice_migration->port < 0 ||
+                spice_migration->port > 0xffff
+                ) {
+                goto error;
+            }
+            break;
+        }
+        case SPICE_OPTION_HOST:
+            if (!val) {
+                goto error;
+            }
+            spice_migration->host = val;
+            break;
+        }
+    } while (args);
+
+    if ((spice_migration->sport == -1 && spice_migration->port == -1) || !spice_migration->host) {
+        red_printf("invalid args port %d sport %d host %s",
+                   spice_migration->port,
+                   spice_migration->sport,
+                   (spice_migration->host) ? spice_migration->host : "NULL");
+        goto error;
+    }
+
+    spice_migration->fd = mig->begin_hook(mig, reds->mig_notifier);
+
+    if (spice_migration->fd == -1) {
+        goto error;
+    }
+
+    spice_migration->write.now = spice_migration->write.buf;
+    spice_migration->write.length = sizeof(uint32_t);
+    version = (uint32_t *)spice_migration->write.buf;
+    *version = REDS_MIG_VERSION;
+    spice_migration->write.handle_done = reds_mig_receive_control;
+    core->set_file_handlers(core, spice_migration->fd, reds_mig_write,
+                            reds_mig_write, spice_migration);
+    return;
+
+error:
+    if (spice_migration) {
+        if (spice_migration->local_args) {
+            free(spice_migration->local_args);
+        }
+        free(spice_migration);
+    }
+
+    reds_mig_disconnect();
+}
+
+static void reds_mig_finished(void *opaque, int completed)
+{
+    SimpleOutItem *item;
+
+    red_printf("");
+    if (reds->listen_socket != -1) {
+        core->set_file_handlers(core, reds->listen_socket, reds_accept, NULL, NULL);
+    }
+
+    if (reds->secure_listen_socket != -1) {
+        core->set_file_handlers(core, reds->secure_listen_socket, reds_accept_ssl_connection,
+                                NULL, NULL);
+    }
+
+    if (reds->peer == NULL) {
+        red_printf("no peer connected");
+        mig->notifier_done(mig, reds->mig_notifier);
+        return;
+    }
+    reds->mig_inprogress = TRUE;
+
+    if (completed) {
+        Channel *channel;
+        RedMigrate *migrate;
+
+        reds->mig_wait_disconnect = TRUE;
+        core->arm_timer(core, reds->mig_timer, MIGRATE_TIMEOUT);
+
+        if (!(item = new_simple_out_item(RED_MIGRATE, sizeof(RedMigrate)))) {
+            red_printf("alloc item failed");
+            reds_disconnect();
+            return;
+        }
+        migrate = (RedMigrate *)item->data;
+        migrate->flags = RED_MIGRATE_NEED_FLUSH | RED_MIGRATE_NEED_DATA_TRANSFER;
+        reds_push_pipe_item(&item->base);
+        channel = reds->channels;
+        while (channel) {
+            channel->migrate(channel);
+            channel = channel->next;
+        }
+    } else {
+        if (!(item = new_simple_out_item(RED_MIGRATE_CANCEL, 0))) {
+            red_printf("alloc item failed");
+            reds_disconnect();
+            return;
+        }
+        reds_push_pipe_item(&item->base);
+        reds_mig_cleanup();
+    }
+}
+
+static int write_all(int fd, const void *in_buf, int len1)
+{
+    int ret, len;
+    uint8_t *buf = (uint8_t *)in_buf;
+
+    len = len1;
+    while (len > 0) {
+        ret = write(fd, buf, len);
+        if (ret < 0) {
+            if (errno != EINTR && errno != EAGAIN) {
+                return -1;
+            }
+        } else if (ret == 0) {
+            break;
+        } else {
+            buf += ret;
+            len -= ret;
+        }
+    }
+    return len1 - len;
+}
+
+static int read_all(int fd, void *in_nuf, int lenl)
+{
+    int ret, len;
+    uint8_t *buf = in_nuf;
+
+    len = lenl;
+    while (len > 0) {
+        ret = read(fd, buf, len);
+        if (ret < 0) {
+            if (errno != EINTR && errno != EAGAIN) {
+                return -1;
+            }
+        } else if (ret == 0) {
+            break;
+        } else {
+            buf += ret;
+            len -= ret;
+        }
+    }
+    return lenl - len;
+}
+
+static void reds_mig_read_all(int fd, void *buf, int len, const char *name)
+{
+    int n = read_all(fd, buf, len);
+    if (n != len) {
+        red_error("read %s failed, n=%d (%s)", name, n, strerror(errno));
+    }
+}
+
+static void reds_mig_write_all(int fd, void *buf, int len, const char *name)
+{
+    int n = write_all(fd, buf, len);
+    if (n != len) {
+        red_error("write %s faile, n=%d (%s)", name, n, strerror(errno));
+    }
+}
+
+static void reds_mig_recv(void *opaque, int fd)
+{
+    uint32_t ack_message = *(uint32_t *)"ack_";
+    char password[RED_MAX_PASSWORD_LENGTH];
+    RedsMigSpiceMessage mig_message;
+    unsigned long f4 = RSA_F4;
+    TicketInfo ticketing_info;
+    uint32_t version;
+    uint32_t resault;
+    BIO *bio;
+
+    BUF_MEM *buff;
+
+    reds_mig_read_all(fd, &version, sizeof(version), "version");
+
+    if (version != REDS_MIG_VERSION) {
+        resault = REDS_MIG_ABORT;
+        reds_mig_write_all(fd, &resault, sizeof(resault), "resault");
+        mig->notifier_done(mig, reds->mig_notifier);
+        return;
+    }
+
+    resault = REDS_MIG_CONTINUE;
+    reds_mig_write_all(fd, &resault, sizeof(resault), "resault");
+
+    ticketing_info.bn = BN_new();
+    if (!ticketing_info.bn) {
+        red_error("OpenSSL BIGNUMS alloc failed");
+    }
+
+    BN_set_word(ticketing_info.bn, f4);
+    if (!(ticketing_info.rsa = RSA_new())) {
+        red_error("OpenSSL RSA alloc failed");
+    }
+
+    RSA_generate_key_ex(ticketing_info.rsa, RED_TICKET_KEY_PAIR_LENGTH, ticketing_info.bn, NULL);
+    ticketing_info.rsa_size = RSA_size(ticketing_info.rsa);
+
+    if (!(bio = BIO_new(BIO_s_mem()))) {
+        red_error("OpenSSL BIO alloc failed");
+    }
+
+    i2d_RSA_PUBKEY_bio(bio, ticketing_info.rsa);
+    BIO_get_mem_ptr(bio, &buff);
+
+    reds_mig_write_all(fd, buff->data, RED_TICKET_PUBKEY_BYTES, "publick key");
+    reds_mig_read_all(fd, ticketing_info.encrypted_ticket.encrypted_data, ticketing_info.rsa_size,
+                      "ticket");
+
+    RSA_private_decrypt(ticketing_info.rsa_size, ticketing_info.encrypted_ticket.encrypted_data,
+                        (unsigned char *)password, ticketing_info.rsa, RSA_PKCS1_OAEP_PADDING);
+
+    BN_free(ticketing_info.bn);
+    BIO_free(bio);
+    RSA_free(ticketing_info.rsa);
+
+    memcpy(reds->taTicket.password, password, sizeof(reds->taTicket.password));
+    reds_mig_read_all(fd, &mig_message, sizeof(mig_message), "mig data");
+    reds->link_id = mig_message.link_id;
+    reds_mig_write_all(fd, &ack_message, sizeof(uint32_t), "ack");
+    mig->notifier_done(mig, reds->mig_notifier);
+}
+
+static void migrate_timout(void *opaque)
+{
+    red_printf("");
+    ASSERT(reds->mig_wait_connect || reds->mig_wait_disconnect);
+    reds_mig_disconnect();
+}
+
+static void key_modifiers_sender(void *opaque)
+{
+    reds_send_keyborad_modifiers(keyboard ? keyboard->get_leds(keyboard) : 0);
+}
+
+uint32_t reds_get_mm_time()
+{
+    struct timespec time_space;
+    clock_gettime(CLOCK_MONOTONIC, &time_space);
+    return time_space.tv_sec * 1000 + time_space.tv_nsec / 1000 / 1000;
+}
+
+void reds_update_mm_timer(uint32_t mm_time)
+{
+    red_dispatcher_set_mm_time(mm_time);
+}
+
+void reds_enable_mm_timer()
+{
+    RedMultiMediaTime *time_mes;
+    SimpleOutItem *item;
+
+    core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+    if (!reds->peer) {
+        return;
+    }
+
+    if (!(item = new_simple_out_item(RED_MULTI_MEDIA_TIME, sizeof(RedMultiMediaTime)))) {
+        red_printf("alloc item failed");
+        reds_disconnect();
+        return;
+    }
+    time_mes = (RedMultiMediaTime *)item->data;
+    time_mes->time = reds_get_mm_time() - MM_TIME_DELTA;
+    reds_push_pipe_item(&item->base);
+}
+
+void reds_desable_mm_timer()
+{
+    core->disarm_timer(core, reds->mm_timer);
+}
+
+static void mm_timer_proc(void *opaque)
+{
+    red_dispatcher_set_mm_time(reds_get_mm_time());
+    core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+}
+
+static void add_monitor_action_commands(QTermInterface *mon)
+{
+    mon->add_action_command_handler(mon, "spice", "set_image_compression", "s",
+                                    reds_do_set_image_compression,
+                                    "",
+                                    "<[on|auto_glz|auto_lz|quic|glz|lz|off]>");
+    mon->add_action_command_handler(mon, "spice", "set_streaming_video", "s",
+                                    reds_do_set_streaming_video,
+                                    "",
+                                    "<on|off>");
+    mon->add_action_command_handler(mon, "spice", "set_playback_compression", "s",
+                                    reds_do_set_playback_compression,
+                                    "",
+                                    "<on|off>");
+    mon->add_action_command_handler(mon, "spice", "set_ticket", "ss?",
+                                    reds_do_set_ticket,
+                                    "<password> [expiration=<seconds>]"
+                                    "[,connected=keep|disconnect|fail]",
+                                    "set the spice connection ticket");
+    mon->add_action_command_handler(mon, "spice", "set_ticket64", "ss?",
+                                    reds_do_set_ticket64,
+                                    "<password> [expiration=<seconds>]"
+                                    "                            [,connected=keep|disconnect|fail]",
+                                    "set the spice connection ticket");
+    mon->add_action_command_handler(mon, "spice", "disable_ticketing", "",
+                                    reds_do_disable_ticketing,
+                                    "",
+                                    "entirely disables OTP");
+    mon->add_action_command_handler(mon, "spice", "set_agent_mouse", "s",
+                                    reds_do_set_agent_mouse,
+                                    "",
+                                    "<on|off>");
+#ifdef RED_STATISTICS
+    mon->add_action_command_handler(mon, "spice", "reset_stat", "",
+                                    do_reset_statistics,
+                                    "",
+                                    "reset spice statistics");
+    mon->add_action_command_handler(mon, "spice", "ping_client", "s?i?",
+                                    do_ping_client,
+                                    "[on [interval]|off]",
+                                    "ping spice client to measure roundtrip");
+#endif
+}
+
+static void add_monitor_info_commands(QTermInterface *mon)
+{
+    mon->add_info_command_handler(mon, "spice", "state",
+                                  reds_do_info_spice,
+                                  "show spice state");
+    mon->add_info_command_handler(mon, "spice", "ticket",
+                                  reds_do_info_ticket,
+                                  "show ticket");
+#ifdef RED_STATISTICS
+    mon->add_info_command_handler(mon, "spice", "stat",
+                                  do_info_statistics,
+                                  "show spice statistics");
+    mon->add_info_command_handler(mon, "spice", "rtt_client",
+                                  do_info_rtt_client,
+                                  "show rtt to spice client");
+#endif
+}
+
+static void attach_to_red_agent(VDIPortInterface *interface)
+{
+    VDIPortState *state = &reds->agent_state;
+
+    vdagent = interface;
+    reds_update_mouse_mode();
+    if (!reds->peer) {
+        return;
+    }
+    state->plug_ref = vdagent->plug(vdagent, &state->plug);
+    reds->agent_state.plug_generation++;
+
+    if (reds->mig_target) {
+        return;
+    }
+
+    reds_send_agent_connected();
+}
+
+static void interface_change_notifier(void *opaque, VDInterface *interface,
+                                      VDInterfaceChangeType change)
+{
+    if (interface->base_version != VM_INTERFACE_VERSION) {
+        red_printf("unsuported base interface version");
+        return;
+    }
+    switch (change) {
+    case VD_INTERFACE_ADDING:
+        if (strcmp(interface->type, VD_INTERFACE_KEYBOARD) == 0) {
+            red_printf("VD_INTERFACE_KEYBOARD");
+            if (keyboard) {
+                red_printf("already have keyboard");
+                return;
+            }
+            if (interface->major_version != VD_INTERFACE_KEYBOARD_MAJOR ||
+                interface->minor_version < VD_INTERFACE_KEYBOARD_MINOR) {
+                red_printf("unsuported keyboard interface");
+                return;
+            }
+            keyboard = (KeyboardInterface *)interface;
+            if (!keyboard->register_leds_notifier(keyboard, reds_on_keyborad_leads_change, NULL)) {
+                red_error("register leds  notifier failed");
+            }
+        } else if (strcmp(interface->type, VD_INTERFACE_MOUSE) == 0) {
+            red_printf("VD_INTERFACE_MOUSE");
+            if (mouse) {
+                red_printf("already have mouse");
+                return;
+            }
+            if (interface->major_version != VD_INTERFACE_MOUSE_MAJOR ||
+                interface->minor_version < VD_INTERFACE_MOUSE_MINOR) {
+                red_printf("unsuported mouse interface");
+                return;
+            }
+            mouse = (MouseInterface *)interface;
+        } else if (strcmp(interface->type, VD_INTERFACE_MIGRATION) == 0) {
+            red_printf("VD_INTERFACE_MIGRATION");
+            if (mig) {
+                red_printf("already have migration");
+                return;
+            }
+            if (interface->major_version != VD_INTERFACE_MIGRATION_MAJOR ||
+                interface->minor_version < VD_INTERFACE_MIGRATION_MINOR) {
+                red_printf("unsuported migration interface");
+                return;
+            }
+            mig = (MigrationInterface *)interface;
+            reds->mig_notifier = mig->register_notifiers(mig, MIGRATION_NOTIFY_SPICE_KEY,
+                                                         reds_mig_started, reds_mig_finished,
+                                                         reds_mig_recv, NULL);
+            if (reds->mig_notifier == INVALID_VD_OBJECT_REF) {
+                red_error("migration register failed");
+            }
+        } else if (strcmp(interface->type, VD_INTERFACE_QXL) == 0) {
+            QXLInterface *qxl_interface;
+
+            red_printf("VD_INTERFACE_QXL");
+            if (interface->major_version != VD_INTERFACE_QXL_MAJOR ||
+                interface->minor_version < VD_INTERFACE_QXL_MINOR) {
+                red_printf("unsuported qxl interface");
+                return;
+            }
+            qxl_interface = (QXLInterface *)interface;
+            red_dispatcher_init(qxl_interface);
+        } else if (strcmp(interface->type, VD_INTERFACE_QTERM) == 0) {
+            static int was_here = FALSE;
+            red_printf("VD_INTERFACE_QTERM");
+            if (was_here) {
+                return;
+            }
+            was_here = TRUE;
+            if (interface->major_version != VD_INTERFACE_QTERM_MAJOR ||
+                interface->minor_version < VD_INTERFACE_QTERM_MINOR) {
+                red_printf("unsuported qterm interface");
+                return;
+            }
+            add_monitor_action_commands((QTermInterface *)interface);
+            add_monitor_info_commands((QTermInterface *)interface);
+        } else if (strcmp(interface->type, VD_INTERFACE_TABLET) == 0) {
+            red_printf("VD_INTERFACE_TABLET");
+            if (tablet) {
+                red_printf("already have tablet");
+                return;
+            }
+            if (interface->major_version != VD_INTERFACE_TABLET_MAJOR ||
+                interface->minor_version < VD_INTERFACE_TABLET_MINOR) {
+                red_printf("unsuported tablet interface");
+                return;
+            }
+            tablet = (TabletInterface *)interface;
+            reds_update_mouse_mode();
+            if (reds->is_client_mouse_allowed) {
+                tablet->set_logical_size(tablet, reds->monitor_mode.x_res,
+                                         reds->monitor_mode.y_res);
+            }
+        } else if (strcmp(interface->type, VD_INTERFACE_PLAYBACK) == 0) {
+            red_printf("VD_INTERFACE_PLAYBACK");
+            if (interface->major_version != VD_INTERFACE_PLAYBACK_MAJOR ||
+                interface->minor_version < VD_INTERFACE_PLAYBACK_MINOR) {
+                red_printf("unsuported playback interface");
+                return;
+            }
+            snd_attach_playback((PlaybackInterface *)interface);
+        } else if (strcmp(interface->type, VD_INTERFACE_RECORD) == 0) {
+            red_printf("VD_INTERFACE_RECORD");
+            if (interface->major_version != VD_INTERFACE_RECORD_MAJOR ||
+                interface->minor_version < VD_INTERFACE_RECORD_MINOR) {
+                red_printf("unsuported record interface");
+                return;
+            }
+            snd_attach_record((RecordInterface *)interface);
+        } else if (strcmp(interface->type, VD_INTERFACE_VDI_PORT) == 0) {
+            red_printf("VD_INTERFACE_VDI_PORT");
+            if (vdagent) {
+                red_printf("vdi port already attached");
+                return;
+            }
+            if (interface->major_version != VD_INTERFACE_VDI_PORT_MAJOR ||
+                interface->minor_version < VD_INTERFACE_VDI_PORT_MINOR) {
+                red_printf("unsuported vdi port interface");
+                return;
+            }
+            attach_to_red_agent((VDIPortInterface *)interface);
+        }
+        break;
+    case VD_INTERFACE_REMOVING:
+        if (strcmp(interface->type, VD_INTERFACE_TABLET) == 0) {
+            red_printf("remove VD_INTERFACE_TABLET");
+            if (interface == (VDInterface *)tablet) {
+                tablet = NULL;
+                reds_update_mouse_mode();
+            }
+            break;
+        } else if (strcmp(interface->type, VD_INTERFACE_PLAYBACK) == 0) {
+            red_printf("remove VD_INTERFACE_PLAYBACK");
+            snd_detach_playback((PlaybackInterface *)interface);
+            break;
+        } else if (strcmp(interface->type, VD_INTERFACE_RECORD) == 0) {
+            red_printf("remove VD_INTERFACE_RECORD");
+            snd_detach_record((RecordInterface *)interface);
+            break;
+        } else if (strcmp(interface->type, VD_INTERFACE_VDI_PORT) == 0) {
+            red_printf("remove VD_INTERFACE_VDI_PORT");
+            if (interface == (VDInterface *)vdagent) {
+                reds_agent_remove();
+            }
+            break;
+        }
+        red_error("VD_INTERFACE_REMOVING unsupported");
+        break;
+    }
+}
+
+static void free_external_agent_buff(VDIPortBuf *in_buf)
+{
+    VDIPortState *state = &reds->agent_state;
+
+    ring_add(&state->external_bufs, &in_buf->link);
+    add_token();
+}
+
+static void free_internal_agent_buff(VDIPortBuf *in_buf)
+{
+    VDIPortState *state = &reds->agent_state;
+
+    ring_add(&state->internal_bufs, &in_buf->link);
+    if (reds->inputs_state && reds->inputs_state->pending_mouse_event) {
+        reds_handle_agent_mouse_event();
+    }
+}
+
+void reds_prepare_read_buf(RedsOutItem *in_nuf, struct iovec* vec, int *len)
+{
+    VDIReadBuf *buf = (VDIReadBuf *)in_nuf;
+
+    vec[0].iov_base = &buf->header;
+    vec[0].iov_len = sizeof(buf->header);
+    vec[1].iov_base = buf->data;
+    vec[1].iov_len = buf->len;
+    *len = 2;
+}
+
+void reds_release_read_buf(RedsOutItem *in_nuf)
+{
+    VDIReadBuf *buf = (VDIReadBuf *)in_nuf;
+
+    ring_add(&reds->agent_state.read_bufs, &buf->out_item.link);
+    read_from_vdi_port();
+}
+
+static void init_vd_agent_resources()
+{
+    VDIPortState *state = &reds->agent_state;
+    int i;
+
+    ring_init(&state->external_bufs);
+    ring_init(&state->internal_bufs);
+    ring_init(&state->write_queue);
+    ring_init(&state->read_bufs);
+
+    state->read_state = VDI_PORT_READ_STATE_READ_HADER;
+    state->recive_pos = (uint8_t *)&state->vdi_chunk_header;
+    state->recive_len = sizeof(state->vdi_chunk_header);
+
+    for (i = 0; i < REDS_AGENT_WINDOW_SIZE; i++) {
+        VDAgentExtBuf *buf = (VDAgentExtBuf *)malloc(sizeof(VDAgentExtBuf));
+        if (!buf) {
+            PANIC("alloc failed");
+        }
+        memset(buf, 0, sizeof(*buf));
+        ring_item_init(&buf->base.link);
+        buf->base.chunk_header.port = VDP_CLIENT_PORT;
+        buf->base.free = free_external_agent_buff;
+        ring_add(&reds->agent_state.external_bufs, &buf->base.link);
+    }
+
+    for (i = 0; i < REDS_NUM_INTERNAL_AGENT_MESSAGES; i++) {
+        VDInternalBuf *buf = (VDInternalBuf *)malloc(sizeof(VDInternalBuf));
+        if (!buf) {
+            PANIC("alloc failed");
+        }
+        memset(buf, 0, sizeof(*buf));
+        ring_item_init(&buf->base.link);
+        buf->base.free = free_internal_agent_buff;
+        buf->base.chunk_header.port = VDP_SERVER_PORT;
+        buf->base.chunk_header.size = sizeof(VDAgentMessage) + sizeof(VDAgentMouseState);
+        buf->header.protocol = VD_AGENT_PROTOCOL;
+        buf->header.type = VD_AGENT_MOUSE_STATE;
+        buf->header.opaque = 0;
+        buf->header.size = sizeof(VDAgentMouseState);
+        ring_add(&reds->agent_state.internal_bufs, &buf->base.link);
+    }
+
+    for (i = 0; i < REDS_VDI_PORT_NUM_RECIVE_BUFFS; i++) {
+        VDIReadBuf *buf = (VDIReadBuf *)malloc(sizeof(VDIReadBuf));
+        if (!buf) {
+            PANIC("alloc failed");
+        }
+        memset(buf, 0, sizeof(*buf));
+        buf->out_item.prepare = reds_prepare_read_buf;
+        buf->out_item.release = reds_release_read_buf;
+        buf->header.type = RED_AGENT_DATA;
+        buf->header.sub_list = 0;
+        ring_item_init(&buf->out_item.link);
+        ring_add(&reds->agent_state.read_bufs, &buf->out_item.link);
+    }
+
+    state->plug.major_version = VD_INTERFACE_VDI_PORT_MAJOR;
+    state->plug.minor_version = VD_INTERFACE_VDI_PORT_MINOR;
+    state->plug.wakeup = reds_agent_wakeup;
+}
+
+const char *version_string = VERSION;
+
+void __attribute__ ((visibility ("default"))) spice_init(CoreInterface *core_interface)
+{
+    VDInterface *interface = NULL;
+
+    red_printf("starting %s", version_string);
+
+    if (core_interface->base.base_version != VM_INTERFACE_VERSION) {
+        red_error("bad base interface version");
+    }
+
+    if (core_interface->base.major_version != VD_INTERFACE_CORE_MAJOR) {
+        red_error("bad core interface version");
+    }
+    core = core_interface;
+    if (core_interface->base.minor_version > 1) {
+        log_proc = core->log;
+    }
+    if (!(reds = malloc(sizeof(RedsState)))) {
+        red_error("reds alloc failed");
+    }
+    memset(reds, 0, sizeof(RedsState));
+    reds->listen_socket = -1;
+    reds->secure_listen_socket = -1;
+    reds->peer = NULL;
+    reds->in_handler.handle_message = reds_main_handle_message;
+    ring_init(&reds->outgoing.pipe);
+    reds->outgoing.vec = reds->outgoing.vec_buf;
+
+    init_vd_agent_resources();
+
+    if (!(reds->mig_timer = core->create_timer(core, migrate_timout, NULL))) {
+        red_error("migration timer create failed");
+    }
+    if (!(reds->key_modifiers_timer = core->create_timer(core, key_modifiers_sender, NULL))) {
+        red_error("key modifiers timer create failed");
+    }
+
+    while ((interface = core->next(core, interface))) {
+        interface_change_notifier(&reds, interface, VD_INTERFACE_ADDING);
+    }
+    core->register_change_notifiers(core, &reds, interface_change_notifier);
+
+#ifdef RED_STATISTICS
+    int shm_name_len = strlen(REDS_STAT_SHM_NAME) + 20;
+    int fd;
+
+    if (!(reds->stat_shm_name = (char *)malloc(shm_name_len))) {
+        red_error("stat_shm_name alloc failed");
+    }
+    snprintf(reds->stat_shm_name, shm_name_len, REDS_STAT_SHM_NAME, getpid());
+    if ((fd = shm_open(reds->stat_shm_name, O_CREAT | O_RDWR, 0444)) == -1) {
+        red_error("statistics shm_open failed, %s", strerror(errno));
+    }
+    if (ftruncate(fd, REDS_STAT_SHM_SIZE) == -1) {
+        red_error("statistics ftruncate failed, %s", strerror(errno));
+    }
+    reds->stat = mmap(NULL, REDS_STAT_SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (reds->stat == (RedsStat *)MAP_FAILED) {
+        red_error("statistics mmap failed, %s", strerror(errno));
+    }
+    memset(reds->stat, 0, REDS_STAT_SHM_SIZE);
+    reds->stat->magic = REDS_STAT_MAGIC;
+    reds->stat->version = REDS_STAT_VERSION;
+    reds->stat->root_index = INVALID_STAT_REF;
+    if (pthread_mutex_init(&reds->stat_lock, NULL)) {
+        red_error("mutex init failed");
+    }
+    if (!(reds->ping_timer = core->create_timer(core, ping_timer_cb, NULL))) {
+        red_error("ping timer create failed");
+    }
+    reds->ping_interval = PING_INTERVAL;
+#endif
+
+    if (!(reds->mm_timer = core->create_timer(core, mm_timer_proc, NULL))) {
+        red_error("mm timer create failed");
+    }
+    core->arm_timer(core, reds->mm_timer, MM_TIMER_GRANULARITY_MS);
+
+    reds_init_net();
+    if (reds->secure_listen_socket != -1) {
+        reds_init_ssl();
+    }
+    inputs_init();
+
+    reds->mouse_mode = RED_MOUSE_MODE_SERVER;
+    atexit(reds_exit);
+}
+
diff --git a/server/reds.h b/server/reds.h
new file mode 100644
index 00000000..ce09e5b6
--- /dev/null
+++ b/server/reds.h
@@ -0,0 +1,70 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_REDS
+#define _H_REDS
+
+#include <stdint.h>
+#include <openssl/ssl.h>
+#include <sys/uio.h>
+
+typedef struct RedsStreamContext {
+    void *ctx;
+
+    int socket;
+
+    SSL *ssl;
+
+    int (*cb_write)(void *, void *, int);
+    int (*cb_read)(void *, void *, int);
+
+    int (*cb_readv)(void *, const struct iovec *vector, int count);
+    int (*cb_writev)(void *, const struct iovec *vector, int count);
+    int (*cb_free)(struct RedsStreamContext *);
+} RedsStreamContext;
+
+typedef struct Channel {
+    struct Channel *next;
+    uint32_t type;
+    uint32_t id;
+    int num_common_caps;
+    uint32_t *common_caps;
+    int num_caps;
+    uint32_t *caps;
+    void (*link)(struct Channel *, RedsStreamContext *peer, int migration, int num_common_caps,
+                 uint32_t *common_caps, int num_caps, uint32_t *caps);
+    void (*shutdown)(struct Channel *);
+    void (*migrate)(struct Channel *);
+    void *data;
+} Channel;
+
+void reds_desable_mm_timer();
+void reds_enable_mm_timer();
+void reds_update_mm_timer(uint32_t mm_time);
+uint32_t reds_get_mm_time();
+void reds_set_client_mouse_allowed(int is_client_mouse_allowed,
+                                   int x_res, int y_res);
+void reds_register_channel(Channel *channel);
+void reds_unregister_channel(Channel *channel);
+
+extern struct CoreInterface *core;
+extern uint64_t bitrate_per_sec;
+
+#define IS_LOW_BANDWIDTH() (bitrate_per_sec < 10 * 1024 * 1024)
+
+#endif
+
diff --git a/server/snd_worker.c b/server/snd_worker.c
new file mode 100644
index 00000000..8cfabaef
--- /dev/null
+++ b/server/snd_worker.c
@@ -0,0 +1,1300 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <celt051/celt.h>
+
+#include "vd_interface.h"
+#include "red_common.h"
+#include "reds.h"
+#include "red_dispatcher.h"
+#include "snd_worker.h"
+
+#define MAX_SEND_VEC 100
+#define MAX_SEND_BUFS 200
+
+#define RECIVE_BUF_SIZE (16 * 1024 * 2)
+
+#define FRAME_SIZE 256
+#define PLAYBACK_BUF_SIZE (FRAME_SIZE * 4)
+
+#define CELT_BIT_RATE (64 * 1024)
+#define CELT_COMPRESSED_FRAME_BYTES (FRAME_SIZE * CELT_BIT_RATE / VD_INTERFACE_PLAYBACK_FREQ / 8)
+
+#define RECORD_SAMPLES_SIZE (RECIVE_BUF_SIZE >> 2)
+
+enum PlaybackeCommand {
+    SND_PLAYBACK_MIGRATE,
+    SND_PLAYBACK_MODE,
+    SND_PLAYBACK_CTRL,
+    SND_PLAYBACK_PCM,
+};
+
+enum RecordCommand {
+    SND_RECORD_MIGRATE,
+    SND_RECORD_CTRL,
+};
+
+#define SND_PLAYBACK_MIGRATE_MASK (1 << SND_PLAYBACK_MIGRATE)
+#define SND_PLAYBACK_MODE_MASK (1 << SND_PLAYBACK_MODE)
+#define SND_PLAYBACK_CTRL_MASK (1 << SND_PLAYBACK_CTRL)
+#define SND_PLAYBACK_PCM_MASK (1 << SND_PLAYBACK_PCM)
+
+#define SND_RECORD_MIGRATE_MASK (1 << SND_RECORD_MIGRATE)
+#define SND_RECORD_CTRL_MASK (1 << SND_RECORD_CTRL)
+
+typedef struct BufDescriptor {
+    uint32_t size;
+    uint8_t *data;
+} BufDescriptor;
+
+typedef struct SndChannel SndChannel;
+typedef void (*send_messages_proc)(void *in_channel);
+typedef int (*handle_message_proc)(SndChannel *channel, RedDataHeader *message);
+typedef void (*on_message_done_proc)(SndChannel *channel);
+typedef void (*cleanup_channel_proc)(SndChannel *channel);
+
+typedef struct SndWorker SndWorker;
+
+struct SndChannel {
+    RedsStreamContext *peer;
+    SndWorker *worker;
+
+    int active;
+    int client_active;
+    int blocked;
+
+    uint32_t command;
+    int migrate;
+    uint32_t ack_generation;
+    uint32_t client_ack_generation;
+    uint32_t out_messages;
+    uint32_t ack_messages;
+
+    struct {
+        RedDataHeader header;
+        uint32_t n_bufs;
+        BufDescriptor bufs[MAX_SEND_BUFS];
+
+        uint32_t size;
+        uint32_t pos;
+    } send_data;
+
+    struct {
+        uint8_t buf[RECIVE_BUF_SIZE];
+        RedDataHeader *message;
+        uint8_t *now;
+        uint8_t *end;
+    } recive_data;
+
+    send_messages_proc send_messages;
+    handle_message_proc handle_message;
+    on_message_done_proc on_message_done;
+    cleanup_channel_proc cleanup;
+};
+
+typedef struct AudioFrame AudioFrame;
+struct AudioFrame {
+    uint32_t time;
+    uint32_t samples[FRAME_SIZE];
+    AudioFrame *next;
+};
+
+typedef struct PlaybackChannel {
+    SndChannel base;
+    AudioFrame frames[3];
+    PlaybackPlug plug;
+    VDObjectRef plug_ref;
+    AudioFrame *free_frames;
+    AudioFrame *in_progress;
+    AudioFrame *pending_frame;
+    CELTMode *celt_mode;
+    CELTEncoder *celt_encoder;
+    int celt_allowed;
+    uint32_t mode;
+    struct {
+        union {
+            RedPlaybackMode mode;
+            RedPlaybackStart start;
+            RedMigrate migrate;
+            uint8_t celt_buf[CELT_COMPRESSED_FRAME_BYTES];
+        } u;
+    } send_data;
+} PlaybackChannel;
+
+struct SndWorker {
+    Channel base;
+    VDInterface *interface;
+    SndChannel *connection;
+    SndWorker *next;
+};
+
+#define RECORD_MIG_VERSION 1
+
+typedef struct __attribute__ ((__packed__)) RecordMigrateData {
+    uint32_t version;
+    uint64_t serial;
+    uint32_t start_time;
+    uint32_t mode;
+    uint32_t mode_time;
+} RecordMigrateData;
+
+typedef struct __attribute__ ((__packed__)) RecordMigrateMessage {
+    RedMigrate migrate;
+    RedDataHeader header;
+    RecordMigrateData data;
+} RecordMigrateMessage;
+
+typedef struct RecordChannel {
+    SndChannel base;
+    RecordPlug plug;
+    VDObjectRef plug_ref;
+    uint32_t samples[RECORD_SAMPLES_SIZE];
+    uint32_t write_pos;
+    uint32_t read_pos;
+    uint32_t mode;
+    uint32_t mode_time;
+    uint32_t start_time;
+    CELTDecoder *celt_decoder;
+    CELTMode *celt_mode;
+    uint32_t celt_buf[FRAME_SIZE];
+    struct {
+        union {
+            RedRecordStart start;
+            RecordMigrateMessage migrate;
+        } u;
+    } send_data;
+} RecordChannel;
+
+static SndWorker *workers = NULL;
+static uint32_t playback_compression = RED_AUDIO_DATA_MODE_CELT_0_5_1;
+
+static void snd_receive(void* data);
+
+static inline BufDescriptor *snd_find_buf(SndChannel *channel, int buf_pos, int *buf_offset)
+{
+    BufDescriptor *buf;
+    int pos = 0;
+
+    for (buf = channel->send_data.bufs; buf_pos >= pos + buf->size; buf++) {
+        pos += buf->size;
+        ASSERT(buf != &channel->send_data.bufs[channel->send_data.n_bufs - 1]);
+    }
+    *buf_offset = buf_pos - pos;
+    return buf;
+}
+
+static inline uint32_t __snd_fill_iovec(BufDescriptor *buf, int skip, struct iovec *vec,
+                                        int *vec_index, long phys_delta)
+{
+    uint32_t size = 0;
+    vec[*vec_index].iov_base = buf->data + skip;
+    vec[*vec_index].iov_len = size = buf->size - skip;
+    (*vec_index)++;
+    return size;
+}
+
+static inline void snd_fill_iovec(SndChannel *channel, struct iovec *vec, int *vec_size)
+{
+    int vec_index = 0;
+    uint32_t pos = channel->send_data.pos;
+    ASSERT(channel->send_data.size != pos && channel->send_data.size > pos);
+
+    do {
+        BufDescriptor *buf;
+        int buf_offset;
+
+        buf = snd_find_buf(channel, pos, &buf_offset);
+        ASSERT(buf);
+        pos += __snd_fill_iovec(buf, buf_offset, vec, &vec_index, 0);
+    } while (vec_index < MAX_SEND_VEC && pos != channel->send_data.size);
+    *vec_size = vec_index;
+}
+
+static void snd_disconnect_channel(SndChannel *channel)
+{
+    SndWorker *worker;
+
+    if (!channel) {
+        return;
+    }
+    channel->cleanup(channel);
+    worker = channel->worker;
+    worker->connection = NULL;
+    core->set_file_handlers(core, channel->peer->socket, NULL, NULL, NULL);
+    channel->peer->cb_free(channel->peer);
+    free(channel);
+}
+
+static void snd_playback_free_frame(PlaybackChannel *playback_channel, AudioFrame *frame)
+{
+    frame->next = playback_channel->free_frames;
+    playback_channel->free_frames = frame;
+}
+
+static void snd_playback_on_message_done(SndChannel *channel)
+{
+    PlaybackChannel *playback_channel = (PlaybackChannel *)channel;
+    if (playback_channel->in_progress) {
+        snd_playback_free_frame(playback_channel, playback_channel->in_progress);
+        playback_channel->in_progress = NULL;
+        if (playback_channel->pending_frame) {
+            channel->command |= SND_PLAYBACK_PCM_MASK;
+        }
+    }
+}
+
+static void snd_record_on_message_done(SndChannel *channel)
+{
+}
+
+static int snd_send_data(SndChannel *channel)
+{
+    uint32_t n;
+
+    if (!channel) {
+        return FALSE;
+    }
+
+    if (!(n = channel->send_data.size - channel->send_data.pos)) {
+        return TRUE;
+    }
+
+    for (;;) {
+        struct iovec vec[MAX_SEND_VEC];
+        int vec_size;
+
+        if (!n) {
+            channel->on_message_done(channel);
+
+            if (channel->blocked) {
+                channel->blocked = FALSE;
+                if (core->set_file_handlers(core, channel->peer->socket, snd_receive,
+                                            NULL, channel) == -1) {
+                    red_printf("qemu_set_fd_handler failed");
+                }
+            }
+            break;
+        }
+
+        snd_fill_iovec(channel, vec, &vec_size);
+        if ((n = channel->peer->cb_writev(channel->peer->ctx, vec, vec_size)) == -1) {
+            switch (errno) {
+            case EAGAIN:
+                channel->blocked = TRUE;
+                if (core->set_file_handlers(core, channel->peer->socket, snd_receive,
+                                            channel->send_messages, channel) == -1) {
+                    red_printf("qemu_set_fd_handler failed");
+                }
+                return FALSE;
+            case EINTR:
+                break;
+            case EPIPE:
+                snd_disconnect_channel(channel);
+                return FALSE;
+            default:
+                red_printf("%s", strerror(errno));
+                snd_disconnect_channel(channel);
+                return FALSE;
+            }
+        } else {
+            channel->send_data.pos += n;
+        }
+        n = channel->send_data.size - channel->send_data.pos;
+    }
+    return TRUE;
+}
+
+static int snd_record_handle_write(RecordChannel *record_channel, RedDataHeader *message)
+{
+    RedcRecordPacket *packet;
+    uint32_t write_pos;
+    uint32_t* data;
+    uint32_t size;
+    uint32_t len;
+    uint32_t now;
+
+    if (!record_channel) {
+        return FALSE;
+    }
+
+    packet = (RedcRecordPacket *)(message + 1);
+    size = message->size - sizeof(*packet);
+
+    if (record_channel->mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+        int celt_err = celt051_decode(record_channel->celt_decoder, packet->data, size,
+                                      (celt_int16_t *)record_channel->celt_buf);
+        if (celt_err != CELT_OK) {
+            red_printf("celt decode failed (%d)", celt_err);
+            return FALSE;
+        }
+        data = record_channel->celt_buf;
+        size = FRAME_SIZE;
+    } else if (record_channel->mode == RED_AUDIO_DATA_MODE_RAW) {
+        data = (uint32_t *)packet->data;
+        size = size >> 2;
+        size = MIN(size, RECORD_SAMPLES_SIZE);
+    } else {
+        return FALSE;
+    }
+
+    write_pos = record_channel->write_pos % RECORD_SAMPLES_SIZE;
+    record_channel->write_pos += size;
+    len = RECORD_SAMPLES_SIZE - write_pos;
+    now = MIN(len, size);
+    size -= now;
+    memcpy(record_channel->samples + write_pos, data, now << 2);
+
+    if (size) {
+        memcpy(record_channel->samples, data + now, size << 2);
+    }
+
+    if (record_channel->write_pos - record_channel->read_pos > RECORD_SAMPLES_SIZE) {
+        record_channel->read_pos = record_channel->write_pos - RECORD_SAMPLES_SIZE;
+    }
+    return TRUE;
+}
+
+static int snd_playback_handle_message(SndChannel *channel, RedDataHeader *message)
+{
+    if (!channel) {
+        return FALSE;
+    }
+
+    switch (message->type) {
+    case REDC_DISCONNECTING:
+        break;
+    default:
+        red_printf("invalid message type %u", message->type);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static int snd_record_handle_message(SndChannel *channel, RedDataHeader *message)
+{
+    RecordChannel *record_channel = (RecordChannel *)channel;
+
+    if (!channel) {
+        return FALSE;
+    }
+    switch (message->type) {
+    case REDC_RECORD_DATA:
+        return snd_record_handle_write((RecordChannel *)channel, message);
+    case REDC_RECORD_MODE: {
+        RedcRecordMode *mode = (RedcRecordMode *)(message + 1);
+        record_channel->mode = mode->mode;
+        record_channel->mode_time = mode->time;
+        if (record_channel->mode != RED_AUDIO_DATA_MODE_CELT_0_5_1 &&
+                                                  record_channel->mode != RED_AUDIO_DATA_MODE_RAW) {
+            red_printf("unsupported mode");
+        }
+        break;
+    }
+    case REDC_RECORD_START_MARK: {
+        RedcRecordStartMark *mark = (RedcRecordStartMark *)(message + 1);
+        record_channel->start_time = mark->time;
+        break;
+    }
+    case REDC_DISCONNECTING:
+        break;
+    case REDC_MIGRATE_DATA: {
+        RecordMigrateData* mig_data = (RecordMigrateData *)(message + 1);
+        if (mig_data->version != RECORD_MIG_VERSION) {
+            red_printf("invalid mig version");
+            break;
+        }
+        record_channel->mode = mig_data->mode;
+        record_channel->mode_time = mig_data->mode_time;
+        record_channel->start_time = mig_data->start_time;
+        break;
+    }
+    default:
+        red_printf("invalid message type %u", message->type);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static void snd_receive(void* data)
+{
+    SndChannel *channel = (SndChannel*)data;
+    if (!channel) {
+        return;
+    }
+
+    for (;;) {
+        ssize_t n;
+        n = channel->recive_data.end - channel->recive_data.now;
+        ASSERT(n);
+        if ((n = channel->peer->cb_read(channel->peer->ctx, channel->recive_data.now, n)) <= 0) {
+            if (n == 0) {
+                snd_disconnect_channel(channel);
+                return;
+            }
+            ASSERT(n == -1);
+            switch (errno) {
+            case EAGAIN:
+                return;
+            case EINTR:
+                break;
+            case EPIPE:
+                snd_disconnect_channel(channel);
+                return;
+            default:
+                red_printf("%s", strerror(errno));
+                snd_disconnect_channel(channel);
+                return;
+            }
+        } else {
+            channel->recive_data.now += n;
+            for (;;) {
+                RedDataHeader *message = channel->recive_data.message;
+                n = channel->recive_data.now - (uint8_t *)message;
+                if (n < sizeof(RedDataHeader) || n < sizeof(RedDataHeader) + message->size) {
+                    break;
+                }
+                if (!channel->handle_message(channel, message)) {
+                    snd_disconnect_channel(channel);
+                    return;
+                }
+                channel->recive_data.message = (RedDataHeader *)((uint8_t *)message +
+                                                                 sizeof(RedDataHeader) +
+                                                                 message->size);
+            }
+            if (channel->recive_data.now == (uint8_t *)channel->recive_data.message) {
+                channel->recive_data.now = channel->recive_data.buf;
+                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+            } else if (channel->recive_data.now == channel->recive_data.end) {
+                memcpy(channel->recive_data.buf, channel->recive_data.message, n);
+                channel->recive_data.now = channel->recive_data.buf + n;
+                channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+            }
+        }
+    }
+}
+
+static inline void __snd_add_buf(SndChannel *channel, void *data, uint32_t size)
+{
+    int pos = channel->send_data.n_bufs++;
+    ASSERT(pos < MAX_SEND_BUFS);
+    channel->send_data.bufs[pos].size = size;
+    channel->send_data.bufs[pos].data = data;
+}
+
+static void snd_add_buf(SndChannel *channel, void *data, uint32_t size)
+{
+    __snd_add_buf(channel, data, size);
+    channel->send_data.header.size += size;
+}
+
+static inline int snd_reset_send_data(SndChannel *channel, uint16_t verb)
+{
+    if (!channel) {
+        return FALSE;
+    }
+
+    channel->send_data.pos = 0;
+    channel->send_data.n_bufs = 0;
+    channel->send_data.header.sub_list = 0;
+    channel->send_data.header.size = 0;
+    channel->send_data.header.type = verb;
+    ++channel->send_data.header.serial;
+    __snd_add_buf(channel, &channel->send_data.header, sizeof(RedDataHeader));
+    return TRUE;
+}
+
+static int snd_playback_send_migrate(PlaybackChannel *channel)
+{
+    if (!snd_reset_send_data((SndChannel *)channel, RED_MIGRATE)) {
+        return FALSE;
+    }
+    channel->send_data.u.migrate.flags = 0;
+    snd_add_buf((SndChannel *)channel, &channel->send_data.u.migrate,
+                sizeof(channel->send_data.u.migrate));
+    channel->base.send_data.size = channel->base.send_data.header.size + sizeof(RedDataHeader);
+    return snd_send_data((SndChannel *)channel);
+}
+
+static int snd_playback_send_start(PlaybackChannel *playback_channel)
+{
+    SndChannel *channel = (SndChannel *)playback_channel;
+    RedPlaybackStart *start;
+    if (!snd_reset_send_data(channel, RED_PLAYBACK_START)) {
+        return FALSE;
+    }
+
+    start = &playback_channel->send_data.u.start;
+    start->channels = VD_INTERFACE_PLAYBACK_CHAN;
+    start->frequency = VD_INTERFACE_PLAYBACK_FREQ;
+    ASSERT(VD_INTERFACE_PLAYBACK_FMT == VD_INTERFACE_AUDIO_FMT_S16);
+    start->format = RED_AUDIO_FMT_S16;
+    start->time = reds_get_mm_time();
+    snd_add_buf(channel, start, sizeof(*start));
+
+    channel->send_data.size = sizeof(RedDataHeader) + sizeof(*start);
+    return snd_send_data(channel);
+}
+
+static int snd_playback_send_stop(PlaybackChannel *playback_channel)
+{
+    SndChannel *channel = (SndChannel *)playback_channel;
+    if (!snd_reset_send_data(channel, RED_PLAYBACK_STOP)) {
+        return FALSE;
+    }
+    channel->send_data.size = sizeof(RedDataHeader);
+    return snd_send_data(channel);
+}
+
+static int snd_playback_send_ctl(PlaybackChannel *playback_channel)
+{
+    SndChannel *channel = (SndChannel *)playback_channel;
+
+    if ((channel->client_active = channel->active)) {
+        return snd_playback_send_start(playback_channel);
+    } else {
+        return snd_playback_send_stop(playback_channel);
+    }
+}
+
+static int snd_record_send_start(RecordChannel *record_channel)
+{
+    SndChannel *channel = (SndChannel *)record_channel;
+    RedRecordStart *start;
+    if (!snd_reset_send_data(channel, RED_RECORD_START)) {
+        return FALSE;
+    }
+
+    start = &record_channel->send_data.u.start;
+    start->channels = VD_INTERFACE_RECORD_CHAN;
+    start->frequency = VD_INTERFACE_RECORD_FREQ;
+    ASSERT(VD_INTERFACE_RECORD_FMT == VD_INTERFACE_AUDIO_FMT_S16);
+    start->format = RED_AUDIO_FMT_S16;
+    snd_add_buf(channel, start, sizeof(*start));
+
+    channel->send_data.size = sizeof(RedDataHeader) + sizeof(*start);
+    return snd_send_data(channel);
+}
+
+static int snd_record_send_stop(RecordChannel *record_channel)
+{
+    SndChannel *channel = (SndChannel *)record_channel;
+    if (!snd_reset_send_data(channel, RED_RECORD_STOP)) {
+        return FALSE;
+    }
+    channel->send_data.size = sizeof(RedDataHeader);
+    return snd_send_data(channel);
+}
+
+static int snd_record_send_ctl(RecordChannel *record_channel)
+{
+    SndChannel *channel = (SndChannel *)record_channel;
+
+    if ((channel->client_active = channel->active)) {
+        return snd_record_send_start(record_channel);
+    } else {
+        return snd_record_send_stop(record_channel);
+    }
+}
+
+static int snd_record_send_migrate(RecordChannel *record_channel)
+{
+    SndChannel *channel = (SndChannel *)record_channel;
+    RecordMigrateMessage* migrate;
+
+    if (!snd_reset_send_data(channel, RED_MIGRATE)) {
+        return FALSE;
+    }
+
+    migrate = &record_channel->send_data.u.migrate;
+    migrate->migrate.flags = RED_MIGRATE_NEED_DATA_TRANSFER;
+    migrate->header.type = RED_MIGRATE_DATA;
+    migrate->header.size = sizeof(RecordMigrateData);
+    migrate->header.serial = ++channel->send_data.header.serial;
+    migrate->header.sub_list = 0;
+
+    migrate->data.version = RECORD_MIG_VERSION;
+    migrate->data.serial = channel->send_data.header.serial;
+    migrate->data.start_time = record_channel->start_time;
+    migrate->data.mode = record_channel->mode;
+    migrate->data.mode_time = record_channel->mode_time;
+
+    snd_add_buf(channel, migrate, sizeof(*migrate));
+    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    channel->send_data.header.size -= sizeof(migrate->header);
+    channel->send_data.header.size -= sizeof(migrate->data);
+    return snd_send_data(channel);
+}
+
+static int snd_playback_send_write(PlaybackChannel *playback_channel)
+{
+    SndChannel *channel = (SndChannel *)playback_channel;
+    AudioFrame *frame;
+
+    if (!snd_reset_send_data(channel, RED_PLAYBACK_DATA)) {
+        return FALSE;
+    }
+
+    frame = playback_channel->in_progress;
+    snd_add_buf(channel, &frame->time, sizeof(frame->time));
+    if (playback_channel->mode == RED_AUDIO_DATA_MODE_CELT_0_5_1) {
+        int n = celt051_encode(playback_channel->celt_encoder, (celt_int16_t *)frame->samples, NULL,
+                               playback_channel->send_data.u.celt_buf, CELT_COMPRESSED_FRAME_BYTES);
+        if (n < 0) {
+            red_printf("celt encode failed");
+            snd_disconnect_channel(channel);
+            return FALSE;
+        }
+        snd_add_buf(channel, playback_channel->send_data.u.celt_buf, n);
+    } else {
+        snd_add_buf(channel, frame->samples, sizeof(frame->samples));
+    }
+
+    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+
+    return snd_send_data(channel);
+}
+
+static int playback_send_mode(PlaybackChannel *playback_channel)
+{
+    SndChannel *channel = (SndChannel *)playback_channel;
+    RedPlaybackMode *mode;
+
+    if (!snd_reset_send_data(channel, RED_PLAYBACK_MODE)) {
+        return FALSE;
+    }
+    mode = &playback_channel->send_data.u.mode;
+    mode->time = reds_get_mm_time();
+    mode->mode = playback_channel->mode;
+    snd_add_buf(channel, mode, sizeof(*mode));
+
+    channel->send_data.size = channel->send_data.header.size + sizeof(RedDataHeader);
+    return snd_send_data(channel);
+}
+
+static void snd_playback_send(void* data)
+{
+    PlaybackChannel *playback_channel = (PlaybackChannel*)data;
+    SndChannel *channel = (SndChannel*)playback_channel;
+
+    if (!playback_channel || !snd_send_data(data)) {
+        return;
+    }
+
+    while (channel->command) {
+        if (channel->command & SND_PLAYBACK_MODE_MASK) {
+            if (!playback_send_mode(playback_channel)) {
+                return;
+            }
+            channel->command &= ~SND_PLAYBACK_MODE_MASK;
+        }
+        if (channel->command & SND_PLAYBACK_PCM_MASK) {
+            ASSERT(!playback_channel->in_progress && playback_channel->pending_frame);
+            playback_channel->in_progress = playback_channel->pending_frame;
+            playback_channel->pending_frame = NULL;
+            channel->command &= ~SND_PLAYBACK_PCM_MASK;
+            if (!snd_playback_send_write(playback_channel)) {
+                red_printf("snd_send_playback_write failed");
+                return;
+            }
+        }
+        if (channel->command & SND_PLAYBACK_CTRL_MASK) {
+            if (!snd_playback_send_ctl(playback_channel)) {
+                return;
+            }
+            channel->command &= ~SND_PLAYBACK_CTRL_MASK;
+        }
+        if (channel->command & SND_PLAYBACK_MIGRATE_MASK) {
+            if (!snd_playback_send_migrate(playback_channel)) {
+                return;
+            }
+            channel->command &= ~SND_PLAYBACK_MIGRATE_MASK;
+        }
+    }
+}
+
+static void snd_record_send(void* data)
+{
+    RecordChannel *record_channel = (RecordChannel*)data;
+    SndChannel *channel = (SndChannel*)record_channel;
+
+    if (!record_channel || !snd_send_data(data)) {
+        return;
+    }
+
+    while (channel->command) {
+        if (channel->command & SND_RECORD_CTRL_MASK) {
+            if (!snd_record_send_ctl(record_channel)) {
+                return;
+            }
+            channel->command &= ~SND_RECORD_CTRL_MASK;
+        }
+        if (channel->command & SND_RECORD_MIGRATE_MASK) {
+            if (!snd_record_send_migrate(record_channel)) {
+                return;
+            }
+            channel->command &= ~SND_RECORD_MIGRATE_MASK;
+        }
+    }
+}
+
+static SndChannel *__new_channel(SndWorker *worker, int size, RedsStreamContext *peer,
+                                 int migrate, send_messages_proc send_messages,
+                                 handle_message_proc handle_message,
+                                 on_message_done_proc on_message_done,
+                                 cleanup_channel_proc cleanup)
+{
+    SndChannel *channel;
+    int delay_val;
+    int flags;
+    int priority;
+    int tos;
+
+    if ((flags = fcntl(peer->socket, F_GETFL)) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    priority = 6;
+    if (setsockopt(peer->socket, SOL_SOCKET, SO_PRIORITY, (void*)&priority,
+                   sizeof(priority)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    tos = IPTOS_LOWDELAY;
+    if (setsockopt(peer->socket, IPPROTO_IP, IP_TOS, (void*)&tos, sizeof(tos)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    delay_val = IS_LOW_BANDWIDTH() ? 0 : 1;
+    if (setsockopt(peer->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val, sizeof(delay_val)) == -1) {
+        red_printf("setsockopt failed, %s", strerror(errno));
+    }
+
+    if (fcntl(peer->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
+        red_printf("accept failed, %s", strerror(errno));
+        goto error1;
+    }
+
+    ASSERT(size >= sizeof(*channel));
+    if (!(channel = malloc(size))) {
+        red_printf("malloc failed");
+        goto error1;
+    }
+    memset(channel, 0, size);
+    channel->peer = peer;
+    channel->worker = worker;
+    channel->recive_data.message = (RedDataHeader *)channel->recive_data.buf;
+    channel->recive_data.now = channel->recive_data.buf;
+    channel->recive_data.end = channel->recive_data.buf + sizeof(channel->recive_data.buf);
+
+    if (core->set_file_handlers(core, peer->socket, snd_receive, NULL, channel) == -1) {
+        red_printf("qemu_set_fd_handler failed, %s", strerror(errno));
+        goto error2;
+    }
+
+    channel->migrate = migrate;
+    channel->send_messages = send_messages;
+    channel->handle_message = handle_message;
+    channel->on_message_done = on_message_done;
+    channel->cleanup = cleanup;
+    return channel;
+
+error2:
+    free(channel);
+
+error1:
+    peer->cb_free(peer);
+    return NULL;
+}
+
+static void snd_shutdown(Channel *channel)
+{
+    SndWorker *worker = (SndWorker *)channel;
+    snd_disconnect_channel(worker->connection);
+}
+
+static void snd_set_command(SndChannel *channel, uint32_t command)
+{
+    if (!channel) {
+        return;
+    }
+    channel->command |= command;
+}
+
+static void snd_playback_start(PlaybackPlug *plug)
+{
+    PlaybackChannel *playback_channel = CONTAINEROF(plug, PlaybackChannel, plug);
+
+    ASSERT(!playback_channel->base.active);
+    reds_desable_mm_timer();
+    playback_channel->base.active = TRUE;
+    if (!playback_channel->base.client_active) {
+        snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
+        snd_playback_send(&playback_channel->base);
+    } else {
+        playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
+    }
+}
+
+static void snd_playback_stop(PlaybackPlug *plug)
+{
+    PlaybackChannel *playback_channel = CONTAINEROF(plug, PlaybackChannel, plug);
+
+    ASSERT(playback_channel->base.active);
+    reds_enable_mm_timer();
+    playback_channel->base.active = FALSE;
+    if (playback_channel->base.client_active) {
+        snd_set_command(&playback_channel->base, SND_PLAYBACK_CTRL_MASK);
+        snd_playback_send(&playback_channel->base);
+    } else {
+        playback_channel->base.command &= ~SND_PLAYBACK_CTRL_MASK;
+        playback_channel->base.command &= ~SND_PLAYBACK_PCM_MASK;
+
+        if (playback_channel->pending_frame) {
+            ASSERT(!playback_channel->in_progress);
+            snd_playback_free_frame(playback_channel,
+                                    playback_channel->pending_frame);
+            playback_channel->pending_frame = NULL;
+        }
+    }
+}
+
+static void snd_playback_get_frame(PlaybackPlug *plug, uint32_t **frame, uint32_t *num_samples)
+{
+    PlaybackChannel *playback_channel = CONTAINEROF(plug, PlaybackChannel, plug);
+
+    ASSERT(playback_channel->base.active);
+    if (!playback_channel->free_frames) {
+        *frame = NULL;
+        *num_samples = 0;
+        return;
+    }
+
+    *frame = playback_channel->free_frames->samples;
+    playback_channel->free_frames = playback_channel->free_frames->next;
+    *num_samples = FRAME_SIZE;
+}
+
+static void snd_playback_put_frame(PlaybackPlug *plug, uint32_t *samples)
+{
+    PlaybackChannel *playback_channel = CONTAINEROF(plug, PlaybackChannel, plug);
+    AudioFrame *frame;
+
+    ASSERT(playback_channel->base.active);
+
+    if (playback_channel->pending_frame) {
+        snd_playback_free_frame(playback_channel, playback_channel->pending_frame);
+    }
+    frame = CONTAINEROF(samples, AudioFrame, samples);
+    frame->time = reds_get_mm_time();
+    red_dispatcher_set_mm_time(frame->time);
+    playback_channel->pending_frame = frame;
+    snd_set_command(&playback_channel->base, SND_PLAYBACK_PCM_MASK);
+    snd_playback_send(&playback_channel->base);
+}
+
+static void on_new_playback_channel(SndWorker *worker)
+{
+    PlaybackChannel *playback_channel = (PlaybackChannel *)worker->connection;
+    PlaybackInterface *interface = (PlaybackInterface *)worker->interface;
+    ASSERT(playback_channel);
+
+    playback_channel->plug_ref = interface->plug(interface, &playback_channel->plug,
+                                                 &playback_channel->base.active);
+    snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_MODE_MASK);
+    if (!playback_channel->base.migrate && playback_channel->base.active) {
+        snd_set_command((SndChannel *)playback_channel, SND_PLAYBACK_CTRL_MASK);
+    }
+    if (playback_channel->base.active) {
+        reds_desable_mm_timer();
+    }
+}
+
+static void snd_playback_cleanup(SndChannel *channel)
+{
+    PlaybackChannel *playback_channel = (PlaybackChannel *)channel;
+    PlaybackInterface *interface = (PlaybackInterface *)channel->worker->interface;
+
+    if (playback_channel->base.active) {
+        reds_enable_mm_timer();
+    }
+    interface->unplug(interface, playback_channel->plug_ref);
+
+    celt051_encoder_destroy(playback_channel->celt_encoder);
+    celt051_mode_destroy(playback_channel->celt_mode);
+}
+
+static void snd_set_playback_peer(Channel *channel, RedsStreamContext *peer, int migration,
+                                  int num_common_caps, uint32_t *common_caps, int num_caps,
+                                  uint32_t *caps)
+{
+    SndWorker *worker = (SndWorker *)channel;
+    PlaybackChannel *playback_channel;
+    CELTEncoder *celt_encoder;
+    CELTMode *celt_mode;
+    int celt_error;
+
+    snd_disconnect_channel(worker->connection);
+
+    if (!(celt_mode = celt051_mode_create(VD_INTERFACE_PLAYBACK_FREQ, VD_INTERFACE_PLAYBACK_CHAN,
+                                          FRAME_SIZE, &celt_error))) {
+        red_printf("create celt mode failed %d", celt_error);
+        return;
+    }
+
+    if (!(celt_encoder = celt051_encoder_create(celt_mode))) {
+        red_printf("create celt encoder failed");
+        goto error_1;
+    }
+
+    if (!(playback_channel = (PlaybackChannel *)__new_channel(worker,
+                                                              sizeof(*playback_channel),
+                                                              peer,
+                                                              migration,
+                                                              snd_playback_send,
+                                                              snd_playback_handle_message,
+                                                              snd_playback_on_message_done,
+                                                              snd_playback_cleanup))) {
+        goto error_2;
+    }
+    worker->connection = &playback_channel->base;
+    snd_playback_free_frame(playback_channel, &playback_channel->frames[0]);
+    snd_playback_free_frame(playback_channel, &playback_channel->frames[1]);
+    snd_playback_free_frame(playback_channel, &playback_channel->frames[2]);
+
+    playback_channel->plug.major_version = VD_INTERFACE_PLAYBACK_MAJOR;
+    playback_channel->plug.minor_version = VD_INTERFACE_PLAYBACK_MINOR;
+    playback_channel->plug.start = snd_playback_start;
+    playback_channel->plug.stop = snd_playback_stop;
+    playback_channel->plug.get_frame = snd_playback_get_frame;
+    playback_channel->plug.put_frame = snd_playback_put_frame;
+    playback_channel->celt_mode = celt_mode;
+    playback_channel->celt_encoder = celt_encoder;
+    playback_channel->celt_allowed = num_caps > 0 && (caps[0] & (1 << RED_PLAYBACK_CAP_CELT_0_5_1));
+    playback_channel->mode = playback_channel->celt_allowed ? playback_compression :
+                                                              RED_AUDIO_DATA_MODE_RAW;
+
+    on_new_playback_channel(worker);
+    snd_playback_send(worker->connection);
+    return;
+
+error_2:
+    celt051_encoder_destroy(celt_encoder);
+
+error_1:
+    celt051_mode_destroy(celt_mode);
+}
+
+static void snd_record_migrate(Channel *channel)
+{
+    SndWorker *worker = (SndWorker *)channel;
+    if (worker->connection) {
+        snd_set_command(worker->connection, SND_RECORD_MIGRATE_MASK);
+        snd_record_send(worker->connection);
+    }
+}
+
+static void snd_record_start(RecordPlug *plug)
+{
+    RecordChannel *record_channel = CONTAINEROF(plug, RecordChannel, plug);
+
+    ASSERT(!record_channel->base.active);
+    record_channel->base.active = TRUE;
+    record_channel->read_pos = record_channel->write_pos = 0;   //todo: improve by
+                                                                //stream generation
+    if (!record_channel->base.client_active) {
+        snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
+        snd_record_send(&record_channel->base);
+    } else {
+        record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
+    }
+}
+
+static void snd_record_stop(RecordPlug *plug)
+{
+    RecordChannel *record_channel = CONTAINEROF(plug, RecordChannel, plug);
+
+    ASSERT(record_channel->base.active);
+    record_channel->base.active = FALSE;
+    if (record_channel->base.client_active) {
+        snd_set_command(&record_channel->base, SND_RECORD_CTRL_MASK);
+        snd_record_send(&record_channel->base);
+    } else {
+        record_channel->base.command &= ~SND_RECORD_CTRL_MASK;
+    }
+}
+
+static uint32_t snd_record_read(RecordPlug *plug, uint32_t num_samples, uint32_t *samples)
+{
+    RecordChannel *record_channel = CONTAINEROF(plug, RecordChannel, plug);
+    uint32_t read_pos;
+    uint32_t now;
+    uint32_t len;
+
+    ASSERT(record_channel->base.active);
+
+    if (record_channel->write_pos < RECORD_SAMPLES_SIZE / 2) {
+        return 0;
+    }
+
+    len = MIN(record_channel->write_pos - record_channel->read_pos, num_samples);
+
+    if (len < num_samples) {
+        SndWorker *worker = record_channel->base.worker;
+        snd_receive(record_channel);
+        if (!worker->connection) {
+            return 0;
+        }
+        len = MIN(record_channel->write_pos - record_channel->read_pos, num_samples);
+    }
+
+    read_pos = record_channel->read_pos % RECORD_SAMPLES_SIZE;
+    record_channel->read_pos += len;
+    now = MIN(len, RECORD_SAMPLES_SIZE - read_pos);
+    memcpy(samples, &record_channel->samples[read_pos], now * 4);
+    if (now < len) {
+        memcpy(samples + now, record_channel->samples, (len - now) * 4);
+    }
+    return len;
+}
+
+static void on_new_record_channel(SndWorker *worker)
+{
+    RecordChannel *record_channel = (RecordChannel *)worker->connection;
+    RecordInterface *interface = (RecordInterface *)worker->interface;
+    ASSERT(record_channel);
+
+    record_channel->plug_ref = interface->plug(interface, &record_channel->plug,
+                                               &record_channel->base.active);
+    if (!record_channel->base.migrate) {
+        if (record_channel->base.active) {
+            snd_set_command((SndChannel *)record_channel, SND_RECORD_CTRL_MASK);
+        }
+    }
+}
+
+static void snd_record_cleanup(SndChannel *channel)
+{
+    RecordChannel *record_channel = (RecordChannel *)channel;
+    RecordInterface *interface = (RecordInterface *)channel->worker->interface;
+    interface->unplug(interface, record_channel->plug_ref);
+
+    celt051_decoder_destroy(record_channel->celt_decoder);
+    celt051_mode_destroy(record_channel->celt_mode);
+}
+
+static void snd_set_record_peer(Channel *channel, RedsStreamContext *peer, int migration,
+                                int num_common_caps, uint32_t *common_caps, int num_caps,
+                                uint32_t *caps)
+{
+    SndWorker *worker = (SndWorker *)channel;
+    RecordChannel *record_channel;
+    CELTDecoder *celt_decoder;
+    CELTMode *celt_mode;
+    int celt_error;
+
+    snd_disconnect_channel(worker->connection);
+
+    if (!(celt_mode = celt051_mode_create(VD_INTERFACE_RECORD_FREQ, VD_INTERFACE_RECORD_CHAN,
+                                          FRAME_SIZE, &celt_error))) {
+        red_printf("create celt mode failed %d", celt_error);
+        return;
+    }
+
+    if (!(celt_decoder = celt051_decoder_create(celt_mode))) {
+        red_printf("create celt decoder failed");
+        goto error_1;
+    }
+
+    if (!(record_channel = (RecordChannel *)__new_channel(worker,
+                                                          sizeof(*record_channel),
+                                                          peer,
+                                                          migration,
+                                                          snd_record_send,
+                                                          snd_record_handle_message,
+                                                          snd_record_on_message_done,
+                                                          snd_record_cleanup))) {
+        goto error_2;
+    }
+
+    worker->connection = &record_channel->base;
+
+    record_channel->plug.major_version = VD_INTERFACE_RECORD_MAJOR;
+    record_channel->plug.minor_version = VD_INTERFACE_RECORD_MINOR;
+    record_channel->plug.start = snd_record_start;
+    record_channel->plug.stop = snd_record_stop;
+    record_channel->plug.read = snd_record_read;
+    record_channel->celt_mode = celt_mode;
+    record_channel->celt_decoder = celt_decoder;
+
+    on_new_record_channel(worker);
+    snd_record_send(worker->connection);
+    return;
+
+error_1:
+    celt051_decoder_destroy(celt_decoder);
+
+error_2:
+    celt051_mode_destroy(celt_mode);
+}
+
+static void snd_playback_migrate(Channel *channel)
+{
+    SndWorker *worker = (SndWorker *)channel;
+
+    if (worker->connection) {
+        snd_set_command(worker->connection, SND_PLAYBACK_MIGRATE_MASK);
+        snd_playback_send(worker->connection);
+    }
+}
+
+static void add_worker(SndWorker *worker)
+{
+    worker->next = workers;
+    workers = worker;
+}
+
+static void remove_worker(SndWorker *worker)
+{
+    SndWorker **now = &workers;
+    while (*now) {
+        if (*now == worker) {
+            *now = worker->next;
+            return;
+        }
+        now = &(*now)->next;
+    }
+    red_printf("not found");
+}
+
+static SndWorker *find_worker(VDInterface *interface)
+{
+    SndWorker *worker = workers;
+    while (worker) {
+        if (worker->interface == interface) {
+            break;
+        }
+        worker = worker->next;
+    }
+    return worker;
+}
+
+void snd_attach_playback(PlaybackInterface *interface)
+{
+    SndWorker *playback_worker;
+    if (!(playback_worker = (SndWorker *)malloc(sizeof(*playback_worker)))) {
+        red_error("playback channel malloc failed");
+    }
+    memset(playback_worker, 0, sizeof(*playback_worker));
+    playback_worker->base.type = RED_CHANNEL_PLAYBACK;
+    playback_worker->base.link = snd_set_playback_peer;
+    playback_worker->base.shutdown = snd_shutdown;
+    playback_worker->base.migrate = snd_playback_migrate;
+    playback_worker->base.data = NULL;
+
+    playback_worker->interface = &interface->base;
+    playback_worker->base.num_caps = 1;
+    if (!(playback_worker->base.caps = malloc(sizeof(uint32_t)))) {
+        PANIC("malloc failed");
+    }
+    playback_worker->base.caps[0] = (1 << RED_PLAYBACK_CAP_CELT_0_5_1);
+
+    add_worker(playback_worker);
+    reds_register_channel(&playback_worker->base);
+}
+
+void snd_attach_record(RecordInterface *interface)
+{
+    SndWorker *record_worker;
+    if (!(record_worker = (SndWorker *)malloc(sizeof(*record_worker)))) {
+        PANIC("malloc failed");
+    }
+
+    memset(record_worker, 0, sizeof(*record_worker));
+    record_worker->base.type = RED_CHANNEL_RECORD;
+    record_worker->base.link = snd_set_record_peer;
+    record_worker->base.shutdown = snd_shutdown;
+    record_worker->base.migrate = snd_record_migrate;
+    record_worker->base.data = NULL;
+
+    record_worker->interface = &interface->base;
+
+    record_worker->base.num_caps = 1;
+    if (!(record_worker->base.caps = malloc(sizeof(uint32_t)))) {
+        PANIC("malloc failed");
+    }
+    record_worker->base.caps[0] = (1 << RED_RECORD_CAP_CELT_0_5_1);
+    add_worker(record_worker);
+    reds_register_channel(&record_worker->base);
+}
+
+static void snd_detach_common(VDInterface *interface)
+{
+    SndWorker *worker = find_worker(interface);
+
+    if (!worker) {
+        return;
+    }
+    remove_worker(worker);
+    snd_disconnect_channel(worker->connection);
+    reds_unregister_channel(&worker->base);
+
+    free(worker->base.common_caps);
+    free(worker->base.caps);
+    free(worker);
+}
+
+void snd_detach_playback(PlaybackInterface *interface)
+{
+    snd_detach_common(&interface->base);
+}
+
+void snd_detach_record(RecordInterface *interface)
+{
+    snd_detach_common(&interface->base);
+}
+
+void snd_set_playback_compression(int on)
+{
+    SndWorker *now = workers;
+
+    playback_compression = on ? RED_AUDIO_DATA_MODE_CELT_0_5_1 : RED_AUDIO_DATA_MODE_RAW;
+    for (; now; now = now->next) {
+        if (now->base.type == RED_CHANNEL_PLAYBACK && now->connection) {
+            PlaybackChannel* playback = (PlaybackChannel*)now->connection;
+            if (!playback->celt_allowed) {
+                ASSERT(playback->mode == RED_AUDIO_DATA_MODE_RAW);
+                continue;
+            }
+            if (playback->mode != playback_compression) {
+                playback->mode = playback_compression;
+                snd_set_command(now->connection, SND_PLAYBACK_MODE_MASK);
+            }
+        }
+    }
+}
+
+int snd_get_playback_compression()
+{
+    return (playback_compression == RED_AUDIO_DATA_MODE_RAW) ? FALSE : TRUE;
+}
+
diff --git a/server/snd_worker.h b/server/snd_worker.h
new file mode 100644
index 00000000..ddcad1c0
--- /dev/null
+++ b/server/snd_worker.h
@@ -0,0 +1,33 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_SND_WORKER
+#define _H_SND_WORKER
+
+#include "vd_interface.h"
+
+void snd_attach_playback(PlaybackInterface *interface);
+void snd_detach_playback(PlaybackInterface *interface);
+
+void snd_attach_record(RecordInterface *interface);
+void snd_detach_record(RecordInterface *interface);
+
+void snd_set_playback_compression(int on);
+int snd_get_playback_compression();
+
+#endif
+
diff --git a/server/spice.h b/server/spice.h
new file mode 100644
index 00000000..26de4f73
--- /dev/null
+++ b/server/spice.h
@@ -0,0 +1,29 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_SPICE
+#define _H_SPICE
+
+#include "vd_interface.h"
+
+extern const char *spice_usage_str[];
+
+int spice_parse_args(const char *args);
+void spice_init(CoreInterface *core);
+
+#endif
+
diff --git a/server/stat.h b/server/stat.h
new file mode 100644
index 00000000..6e5d7e79
--- /dev/null
+++ b/server/stat.h
@@ -0,0 +1,48 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _H_STAT
+#define _H_STAT
+
+#include <stdint.h>
+
+typedef uint32_t StatNodeRef;
+#define INVALID_STAT_REF (~(StatNodeRef)0)
+
+#ifdef RED_STATISTICS
+
+StatNodeRef stat_add_node(StatNodeRef parent, const char *name, int visible);
+void stat_remove_node(StatNodeRef node);
+uint64_t *stat_add_counter(StatNodeRef parent, const char *name, int visible);
+void stat_remove_counter(uint64_t *counter);
+
+#define stat_inc_counter(counter, value) {  \
+    if (counter) {                          \
+        *(counter) += (value);              \
+    }                                       \
+}
+
+#else
+#define stat_add_node(p, n, v) INVALID_STAT_REF
+#define stat_remove_node(n)
+#define stat_add_counter(p, n, v) NULL
+#define stat_remove_counter(c)
+#define stat_inc_counter(c, v)
+#endif
+
+#endif
+
diff --git a/server/vd_interface.h b/server/vd_interface.h
new file mode 100644
index 00000000..932c0b13
--- /dev/null
+++ b/server/vd_interface.h
@@ -0,0 +1,334 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+       * Neither the name of the copyright holder nor the names of its
+         contributors may be used to endorse or promote products derived
+         from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+   TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+   PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _H_VD_INTERFACE
+#define _H_VD_INTERFACE
+
+#include <stdint.h>
+
+#define VM_INTERFACE_VERSION 1
+typedef unsigned long VDObjectRef;
+#define INVALID_VD_OBJECT_REF 0
+typedef struct VDInterface VDInterface;
+
+struct VDInterface {
+    uint32_t base_version;
+    const char *type;
+    unsigned int id;
+    const char *description;
+    //todo: swap minor major order on VM_INTERFACE_VERSION change
+    //      (here and in spacific interfaces)
+    uint32_t minor_version;
+    uint32_t major_version;
+};
+
+#define VD_INTERFACE_CORE "core"
+#define VD_INTERFACE_CORE_MAJOR 1
+#define VD_INTERFACE_CORE_MINOR 2
+typedef struct CoreInterface CoreInterface;
+typedef enum {
+    VD_INTERFACE_ADDING,
+    VD_INTERFACE_REMOVING,
+} VDInterfaceChangeType;
+
+typedef enum {
+    VD_LOG_ERROR = 1,
+    VD_LOG_WARN,
+    VD_LOG_INFO,
+} LogLevel;
+
+typedef void (*vd_interface_change_notifier_t)(void *opaque, VDInterface *interface,
+                                               VDInterfaceChangeType change);
+typedef void (*timer_callback_t)(void *opaque);
+
+struct CoreInterface {
+    VDInterface base;
+
+    VDInterface *(*next)(CoreInterface *core, VDInterface *prev);
+
+    VDObjectRef (*register_change_notifiers)(CoreInterface *core, void *opaque,
+                                             vd_interface_change_notifier_t in_notifier);
+    void (*unregister_change_notifiers)(CoreInterface *core, VDObjectRef notifier);
+
+    VDObjectRef (*create_timer)(CoreInterface *core, timer_callback_t, void *opaue);
+    void (*arm_timer)(CoreInterface *core, VDObjectRef timer, uint32_t ms);
+    void (*disarm_timer)(CoreInterface *core, VDObjectRef timer);
+    void (*destroy_timer)(CoreInterface *core, VDObjectRef timer);
+
+    int (*set_file_handlers)(CoreInterface *core, int fd,
+                             void (*on_read)(void *),
+                             void (*on_write)(void *),
+                             void *opaque);
+
+    void (*term_printf)(CoreInterface *core, const char* str, ...);
+    void (*log)(CoreInterface *core, LogLevel level, const char* component,
+                const char* format, ...);
+};
+
+#define VD_INTERFACE_QXL "qxl"
+#define VD_INTERFACE_QXL_MAJOR 1
+#define VD_INTERFACE_QXL_MINOR 2
+typedef struct QXLInterface QXLInterface;
+typedef void (*qxl_mode_change_notifier_t)(void *opaque);
+typedef struct QXLWorker QXLWorker;
+union QXLReleaseInfo;
+struct QXLCommand;
+struct QXLWorker {
+    uint32_t minor_version;
+    uint32_t major_version;
+    void (*attach)(QXLWorker *worker);
+    void (*detach)(QXLWorker *worker);
+    void (*wakeup)(QXLWorker *worker);
+    void (*oom)(QXLWorker *worker);
+    void (*save)(QXLWorker *worker);
+    void (*load)(QXLWorker *worker);
+    void (*start)(QXLWorker *worker);
+    void (*stop)(QXLWorker *worker);
+    void (*update_area)(QXLWorker *worker);
+};
+
+typedef struct DrawArea {
+    uint8_t *buf;
+    uint32_t size;
+    uint8_t *line_0;
+    uint32_t width;
+    uint32_t heigth;
+    int stride;
+} DrawArea;
+
+typedef struct QXLDevInfo {
+    long phys_delta;
+    unsigned long phys_start;
+    unsigned long phys_end;
+
+    uint32_t x_res;
+    uint32_t y_res;
+    uint32_t bits;
+    uint32_t use_hardware_cursor;
+
+    DrawArea draw_area;
+
+    uint32_t ram_size;
+} QXLDevInfo;
+
+struct QXLInterface {
+    VDInterface base;
+
+    uint16_t pci_vendor;
+    uint16_t pci_id;
+    uint8_t pci_revision;
+
+    void (*attache_worker)(QXLInterface *qxl, QXLWorker *qxl_worker);
+    void (*set_compression_level)(QXLInterface *qxl, int level);
+    void (*set_mm_time)(QXLInterface *qxl, uint32_t mm_time);
+    VDObjectRef (*register_mode_change)(QXLInterface *qxl, qxl_mode_change_notifier_t,
+                                        void *opaque);
+    void (*unregister_mode_change)(QXLInterface *qxl, VDObjectRef notifier);
+
+    void (*get_info)(QXLInterface *qxl, QXLDevInfo *info);
+    int (*get_command)(QXLInterface *qxl, struct QXLCommand *cmd);
+    int (*req_cmd_notification)(QXLInterface *qxl);
+    int (*has_command)(QXLInterface *qxl);
+    void (*release_resource)(QXLInterface *qxl, union QXLReleaseInfo *release_info);
+    int (*get_cursor_command)(QXLInterface *qxl, struct QXLCommand *cmd);
+    int (*req_cursor_notification)(QXLInterface *qxl);
+    const struct Rect *(*get_update_area)(QXLInterface *qxl);
+    void (*notify_update)(QXLInterface *qxl, uint32_t update_id);
+    void (*set_save_data)(QXLInterface *qxl, void *data, int size);
+    void *(*get_save_data)(QXLInterface *qxl);
+    int (*flush_resources)(QXLInterface *qxl);
+};
+
+#define VD_INTERFACE_KEYBOARD "keyboard"
+#define VD_INTERFACE_KEYBOARD_MAJOR 1
+#define VD_INTERFACE_KEYBOARD_MINOR 1
+typedef struct KeyboardInterface KeyboardInterface;
+typedef void (*keyborad_leads_notifier_t)(void *opaque, uint8_t leds);
+
+struct KeyboardInterface {
+    VDInterface base;
+
+    void (*push_scan_freg)(KeyboardInterface *keyboard, uint8_t frag);
+    uint8_t (*get_leds)(KeyboardInterface *keyboard);
+    VDObjectRef (*register_leds_notifier)(KeyboardInterface *keyboard,
+                                          keyborad_leads_notifier_t notifier, void *opaque);
+    void (*unregister_leds_notifayer)(KeyboardInterface *keyboard, VDObjectRef notifier);
+};
+
+#define VD_INTERFACE_MOUSE "mouse"
+#define VD_INTERFACE_MOUSE_MAJOR 1
+#define VD_INTERFACE_MOUSE_MINOR 1
+typedef struct MouseInterface MouseInterface;
+
+struct MouseInterface {
+    VDInterface base;
+
+    void (*moution)(MouseInterface* mouse, int dx, int dy, int dz,
+                    uint32_t buttons_state);
+    void (*buttons)(MouseInterface* mouse, uint32_t buttons_state);
+};
+
+#define VD_INTERFACE_TABLET "tablet"
+#define VD_INTERFACE_TABLET_MAJOR 1
+#define VD_INTERFACE_TABLET_MINOR 1
+typedef struct TabletInterface TabletInterface;
+
+struct TabletInterface {
+    VDInterface base;
+
+    void (*set_logical_size)(TabletInterface* tablet, int width, int height);
+    void (*position)(TabletInterface* tablet, int x, int y, uint32_t buttons_state);
+    void (*wheel)(TabletInterface* tablet, int wheel_moution, uint32_t buttons_state);
+    void (*buttons)(TabletInterface* tablet, uint32_t buttons_state);
+};
+
+#define VD_INTERFACE_MIGRATION "migration"
+#define VD_INTERFACE_MIGRATION_MAJOR 1
+#define VD_INTERFACE_MIGRATION_MINOR 1
+typedef struct MigrationInterface MigrationInterface;
+typedef void (*migration_notify_started_t)(void *opaque, const char *args);
+typedef void (*migration_notify_finished_t)(void *opaque, int completed);
+typedef void (*migration_notify_recv_t)(void *opaque, int fd);
+
+struct MigrationInterface {
+    VDInterface base;
+
+    VDObjectRef (*register_notifiers)(MigrationInterface* mig, const char *key,
+                                      migration_notify_started_t,
+                                      migration_notify_finished_t,
+                                      migration_notify_recv_t,
+                                      void *opaque);
+    void (*unregister_notifiers)(MigrationInterface* mig, VDObjectRef notifier);
+    void (*notifier_done)(MigrationInterface *mig, VDObjectRef notifier);
+    int (*begin_hook)(MigrationInterface *mig, VDObjectRef notifier);
+};
+
+#define VD_INTERFACE_QTERM "qemu_terminal"
+#define VD_INTERFACE_QTERM_MAJOR 1
+#define VD_INTERFACE_QTERM_MINOR 1
+typedef struct QTermInterface QTermInterface;
+
+struct QTermInterface {
+    VDInterface base;
+
+    VDObjectRef (*add_action_command_handler)(QTermInterface *term, const char *module_name,
+                                              const char *name,
+                                              const char *args_type,
+                                              void *handler,
+                                              const char *params,
+                                              const char *help);
+    void (*remove_action_command_handler)(QTermInterface *term, VDObjectRef obj);
+
+    VDObjectRef (*add_info_command_handler)(QTermInterface *term, const char *module_name,
+                                            const char *name,
+                                            void *handler,
+                                            const char *help);
+    void (*remove_info_command_handler)(QTermInterface *term, VDObjectRef obj);
+};
+
+#define VD_INTERFACE_PLAYBACK "playback"
+#define VD_INTERFACE_PLAYBACK_MAJOR 1
+#define VD_INTERFACE_PLAYBACK_MINOR 1
+typedef struct PlaybackInterface PlaybackInterface;
+
+enum {
+    VD_INTERFACE_AUDIO_FMT_S16 = 1,
+};
+
+#define VD_INTERFACE_PLAYBACK_FREQ 44100
+#define VD_INTERFACE_PLAYBACK_CHAN 2
+#define VD_INTERFACE_PLAYBACK_FMT VD_INTERFACE_AUDIO_FMT_S16
+
+typedef struct PlaybackPlug PlaybackPlug;
+struct PlaybackPlug {
+    uint32_t minor_version;
+    uint32_t major_version;
+    void (*start)(PlaybackPlug *plug);
+    void (*stop)(PlaybackPlug *plug);
+    void (*get_frame)(PlaybackPlug *plug, uint32_t **frame, uint32_t *samples);
+    void (*put_frame)(PlaybackPlug *plug, uint32_t *frame);
+};
+
+struct PlaybackInterface {
+    VDInterface base;
+
+    VDObjectRef (*plug)(PlaybackInterface *playback, PlaybackPlug* plug, int *enable);
+    void (*unplug)(PlaybackInterface *playback, VDObjectRef);
+};
+
+#define VD_INTERFACE_RECORD "record"
+#define VD_INTERFACE_RECORD_MAJOR 2
+#define VD_INTERFACE_RECORD_MINOR 1
+typedef struct RecordInterface RecordInterface;
+
+#define VD_INTERFACE_RECORD_FREQ 44100
+#define VD_INTERFACE_RECORD_CHAN 2
+#define VD_INTERFACE_RECORD_FMT VD_INTERFACE_AUDIO_FMT_S16
+
+
+typedef struct RecordPlug RecordPlug;
+struct RecordPlug {
+    uint32_t minor_version;
+    uint32_t major_version;
+    void (*start)(RecordPlug *plug);
+    void (*stop)(RecordPlug *plug);
+    uint32_t (*read)(RecordPlug *plug, uint32_t num_samples, uint32_t *samples);
+};
+
+struct RecordInterface {
+    VDInterface base;
+
+    VDObjectRef (*plug)(RecordInterface *recorder, RecordPlug* plug, int *enable);
+    void (*unplug)(RecordInterface *recorder, VDObjectRef);
+};
+
+#define VD_INTERFACE_VDI_PORT "vdi_port"
+#define VD_INTERFACE_VDI_PORT_MAJOR 1
+#define VD_INTERFACE_VDI_PORT_MINOR 1
+typedef struct VDIPortInterface VDIPortInterface;
+
+typedef struct VDIPortPlug VDIPortPlug;
+struct VDIPortPlug {
+    uint32_t minor_version;
+    uint32_t major_version;
+    void (*wakeup)(VDIPortPlug *plug);
+};
+
+struct VDIPortInterface {
+    VDInterface base;
+
+    VDObjectRef (*plug)(VDIPortInterface *port, VDIPortPlug* plug);
+    void (*unplug)(VDIPortInterface *port, VDObjectRef plug);
+    int (*write)(VDIPortInterface *port, VDObjectRef plug, const uint8_t *buf, int len);
+    int (*read)(VDIPortInterface *port, VDObjectRef plug, uint8_t *buf, int len);
+};
+
+#endif
+
diff --git a/spice.pc.in b/spice.pc.in
new file mode 100644
index 00000000..5639f4ae
--- /dev/null
+++ b/spice.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: spice
+Description: SPICE server library
+Version: @VERSION@
+
+Requires: @SPICE_REQUIRES@
+Libs: -L${libdir} -lspice
+Libs.private: @SPICE_NONPKGCONFIG_LIBS@
+Cflags: -I${includedir}/libspice
diff --git a/tools/bitmap_to_c.c b/tools/bitmap_to_c.c
new file mode 100644
index 00000000..3329d5ed
--- /dev/null
+++ b/tools/bitmap_to_c.c
@@ -0,0 +1,396 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+#define TRUE 1
+#define FALSE 0
+
+#define ERROR(str) printf("%s: error: %s\n", prog_name, str); exit(-1);
+
+static char *prog_name = NULL;
+
+static size_t read_input(const char *file_name, uint8_t** out_buf)
+{
+    int fd = open(file_name, O_RDONLY);
+    if (fd == -1) {
+        ERROR("open source file failed");
+        return 0;
+    }
+    struct stat file_stat;
+    if (fstat(fd, &file_stat) == -1) {
+        ERROR("fstat on source file failed");
+        return 0;
+    }
+
+    uint8_t *buf = malloc(file_stat.st_size);
+
+    if (!buf) {
+        close(fd);
+        ERROR("alloc mem failed");
+        return 0;
+    }
+
+    size_t to_read = file_stat.st_size;
+    uint8_t *buf_pos = buf;
+    while (to_read) {
+        int n = read(fd, buf_pos, to_read);
+        if (n <= 0) {
+            ERROR("read from source file failed");
+            close(fd);
+            free(buf);
+            return 0;
+        }
+        to_read -= n;
+        buf_pos += n;
+    }
+    close(fd);
+    *out_buf = buf;
+    return file_stat.st_size;
+}
+
+typedef struct __attribute__ ((__packed__)) BitmpaHeader {
+    uint32_t header_size;
+    uint32_t width;
+    uint32_t height;
+    uint16_t plans;
+    uint16_t bpp;
+    uint32_t compression;
+    uint32_t image_size;
+    uint32_t horizontal_resolution;
+    uint32_t vertical_resolution;
+    uint32_t num_colors;
+    uint32_t important_colors;
+} BitmpaHeader;
+
+typedef struct __attribute__ ((__packed__)) BMPFileHeader {
+    uint16_t magic;
+    uint32_t file_size;
+    uint32_t reserved;
+    uint32_t data_offset;
+    BitmpaHeader header;
+} BMPFileHeader;
+
+#define BI_RGB 0
+
+typedef struct Pixmap {
+    uint32_t width;
+    uint32_t height;
+    uint32_t stride;
+    uint32_t bpp;
+    uint8_t* data;
+} Pixmap;
+
+static Pixmap *init_bitmap(size_t input_size, uint8_t *buf)
+{
+    BMPFileHeader *file_header;
+    uint8_t *pixels;
+    Pixmap *pixmap;
+    uint32_t stride;
+
+
+    if (input_size < sizeof(BMPFileHeader)) {
+        ERROR("invalid source file");
+        return NULL;
+    }
+
+    file_header = (BMPFileHeader *)buf;
+
+    if (file_header->magic != 0x4d42) {
+        ERROR("bad bitmap magic");
+        return NULL;
+    }
+
+    if (file_header->file_size != input_size) {
+        ERROR("invalid source file");
+        return NULL;
+    }
+
+    if (file_header->header.header_size != 40 || file_header->header.plans != 1 ||
+                                                        file_header->header.compression != BI_RGB ||
+                                                        !file_header->header.width ||
+                                                        !file_header->header.height) {
+        ERROR("invalid bitmap header");
+        return NULL;
+    }
+
+    if (file_header->header.bpp == 32) {
+        stride = file_header->header.width * sizeof(uint32_t);
+    } else if (file_header->header.bpp == 24) {
+        stride = ALIGN(file_header->header.width * 3, 4);
+    } else {
+        ERROR("unsupported bpp");
+        return NULL;
+    }
+
+    if (file_header->header.height * stride > file_header->header.image_size) {
+        ERROR("image size is to small");
+        return NULL;
+    }
+    pixels = buf + file_header->data_offset;
+    if (pixels < (uint8_t *)(file_header + 1) ||
+                                       pixels + file_header->header.image_size > buf + input_size) {
+        ERROR("bad data offset");
+        return NULL;
+    }
+
+    if (!(pixmap = (Pixmap *)malloc(sizeof(*pixmap)))) {
+        ERROR("alloc mem failed");
+        return NULL;
+    }
+
+    pixmap->width = file_header->header.width;
+    pixmap->height = file_header->header.height;
+    pixmap->stride = stride;
+    pixmap->bpp = file_header->header.bpp;
+    pixmap->data = pixels;
+    return pixmap;
+}
+
+static inline void put_char(FILE* f, uint8_t val)
+{
+    fprintf(f, "0x%.2x,", val);
+}
+
+static void do_dump_with_alpha_conversion(const Pixmap *pixmap, FILE *f)
+{
+    uint8_t *line = (uint8_t *)(pixmap->data + ((pixmap->height - 1) * pixmap->stride));
+    int line_size = 0;
+    int i, j;
+
+    for (i = 0; i < pixmap->height; i++) {
+        uint8_t *now = line;
+        for (j = 0; j < pixmap->width; j++, now += 4) {
+            if ((line_size++ % 6) == 0) {
+                fprintf(f, "\n\t\t");
+            }
+            double alpha = (double)now[3] / 0xff;
+            put_char(f, alpha * now[0]);
+            put_char(f, alpha * now[1]);
+            put_char(f, alpha * now[2]);
+            put_char(f, now[3]);
+        }
+        line -= pixmap->stride;
+    }
+}
+
+static void do_dump_32bpp(const Pixmap *pixmap, FILE *f)
+{
+    uint8_t *line = (uint8_t *)(pixmap->data + ((pixmap->height - 1) * pixmap->stride));
+    int line_size = 0;
+    int i, j;
+
+    for (i = 0; i < pixmap->height; i++) {
+        uint8_t *now = line;
+        for (j = 0; j < pixmap->width; j++, now += 4) {
+            if ((line_size++ % 6) == 0) {
+                fprintf(f, "\n\t\t");
+            }
+            put_char(f, now[0]);
+            put_char(f, now[1]);
+            put_char(f, now[2]);
+            put_char(f, now[3]);
+        }
+        line -= pixmap->stride;
+    }
+}
+
+static void do_dump_24bpp(const Pixmap *pixmap, FILE *f)
+{
+    uint8_t *line = (uint8_t *)(pixmap->data + ((pixmap->height - 1) * pixmap->stride));
+    int line_size = 0;
+    int i, j;
+
+    for (i = 0; i < pixmap->height; i++) {
+        uint8_t *now = line;
+        for (j = 0; j < pixmap->width; j++, now += 3) {
+            if ((line_size++ % 6) == 0) {
+                fprintf(f, "\n\t\t");
+            }
+            put_char(f, now[0]);
+            put_char(f, now[1]);
+            put_char(f, now[2]);
+            put_char(f, 0);
+        }
+        line -= pixmap->stride;
+    }
+}
+
+static int pixmap_to_c_struct(const Pixmap *pixmap, const char *dest_file, const char *image_name,
+                              int alpha_convertion)
+{
+    int fd;
+    FILE *f;
+
+    if ((fd = open(dest_file, O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1) {
+        ERROR("open dest file failed");
+        return -1;
+    }
+
+    if (!(f = fdopen(fd, "w"))) {
+        ERROR("fdopen failed");
+        close(fd);
+        return -1;
+    }
+
+    uint32_t data_size = pixmap->width * sizeof(uint32_t) * pixmap->height;
+    fprintf(f, "static const struct {\n"
+               "\tuint32_t width;\n"
+               "\tuint32_t height;\n"
+               "\tuint8_t pixel_data[%u];\n"
+               "} %s = { %u, %u, {",
+            data_size, image_name, pixmap->width, pixmap->height);
+
+    if (alpha_convertion) {
+        if (pixmap->bpp != 32) {
+            ERROR("32 bpp is requred for alpha option")
+        }
+        do_dump_with_alpha_conversion(pixmap, f);
+    } else if (pixmap->bpp == 32) {
+        do_dump_32bpp(pixmap, f);
+    } else {
+        do_dump_24bpp(pixmap, f);
+    }
+
+    fseek(f, -1, SEEK_CUR);
+    fprintf(f, "}\n};\n");
+    fclose(f);
+    close(fd);
+    return 0;
+}
+
+enum {
+    ALPHA_OPT = 'a',
+    HELP_OPT = 'h',
+    NAME_OPT = 'n',
+};
+
+static void usage()
+{
+    printf("usage: %s [--alpha] [--name <struct name>] SOURCE [DEST]\n", prog_name);
+    printf("       %s --help\n", prog_name);
+}
+
+const struct option longopts[] = {
+    {"help", no_argument, NULL, HELP_OPT},
+    {"alpha", no_argument, NULL, ALPHA_OPT},
+    {"name", required_argument, NULL, NAME_OPT},
+    {NULL, 0, NULL, 0},
+};
+
+int main(int argc, char **argv)
+{
+    size_t input_size;
+    uint8_t* buf;
+    Pixmap *pixmap;
+    int opt;
+    int alpha_convertion = FALSE;
+    char *struct_name = NULL;
+    char *src = NULL;
+    char *dest = NULL;
+
+
+    if (!(prog_name = strrchr(argv[0], '/'))) {
+        prog_name = argv[0];
+    } else {
+        prog_name++;
+    }
+
+
+    while ((opt = getopt_long(argc, argv, "ah", longopts, NULL)) != -1) {
+        switch (opt) {
+        case 0:
+        case '?':
+            usage();
+            exit(-1);
+        case ALPHA_OPT:
+            alpha_convertion = TRUE;
+            break;
+        case HELP_OPT:
+            usage();
+            exit(0);
+        case NAME_OPT:
+            struct_name = optarg;
+            break;
+        }
+    }
+
+    int more = argc - optind;
+    switch (more) {
+    case 1: {
+        char *slash;
+        char *dot;
+
+        dest = malloc(strlen(argv[optind]) + 3);
+        strcpy(dest, argv[optind]);
+        dot = strrchr(dest, '.');
+        slash = strrchr(dest, '/');
+        if (!dot || (slash && slash > dot)) {
+            strcat(dest, ".c");
+        } else {
+            strcpy(dot, ".c");
+        }
+        break;
+    }
+    case 2:
+        dest = argv[optind + 1];
+        //todo: if dir strcat src name
+        break;
+    default:
+        usage();
+        exit(-1);
+    }
+
+    src = argv[optind];
+
+    if (!struct_name) {
+        char *struct_name_src;
+        char *dot;
+
+        struct_name_src = strrchr(dest, '/');
+        if (!struct_name_src) {
+            struct_name_src = dest;
+        } else {
+            ++struct_name_src;
+        }
+        struct_name = malloc(strlen(struct_name_src) + 1);
+        strcpy(struct_name, struct_name_src);
+        if ((dot = strchr(struct_name, '.'))) {
+            *dot = 0;
+        }
+    }
+
+    if (!(input_size = read_input(src, &buf))) {
+        return -1;
+    }
+
+    if (!(pixmap = init_bitmap(input_size, buf))) {
+        return -1;
+    }
+    return pixmap_to_c_struct(pixmap, dest, struct_name, alpha_convertion);
+}
+
diff --git a/tools/icon_to_c.c b/tools/icon_to_c.c
new file mode 100644
index 00000000..79ae5fac
--- /dev/null
+++ b/tools/icon_to_c.c
@@ -0,0 +1,369 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+
+#define ALIGN(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
+#define TRUE 1
+#define FALSE 0
+
+#define ERROR(str) printf("%s: error: %s\n", prog_name, str); exit(-1);
+
+static char *prog_name = NULL;
+
+static size_t read_input(const char *file_name, uint8_t** out_buf)
+{
+    int fd = open(file_name, O_RDONLY);
+    if (fd == -1) {
+        ERROR("open source file failed");
+        return 0;
+    }
+    struct stat file_stat;
+    if (fstat(fd, &file_stat) == -1) {
+        ERROR("fstat on source file failed");
+        return 0;
+    }
+
+    uint8_t *buf = malloc(file_stat.st_size);
+
+    if (!buf) {
+        close(fd);
+        ERROR("alloc mem failed");
+        return 0;
+    }
+
+    size_t to_read = file_stat.st_size;
+    uint8_t *buf_pos = buf;
+    while (to_read) {
+        int n = read(fd, buf_pos, to_read);
+        if (n <= 0) {
+            ERROR("read from source file failed");
+            close(fd);
+            free(buf);
+            return 0;
+        }
+        to_read -= n;
+        buf_pos += n;
+    }
+    close(fd);
+    *out_buf = buf;
+    return file_stat.st_size;
+}
+
+typedef struct __attribute__ ((__packed__)) BitmpaHeader {
+    uint32_t header_size;
+    uint32_t width;
+    uint32_t height;
+    uint16_t plans;
+    uint16_t bpp;
+    uint32_t compression;
+    uint32_t image_size;
+    uint32_t horizontal_resolution;
+    uint32_t vertical_resolution;
+    uint32_t num_colors;
+    uint32_t important_colors;
+} BitmpaHeader;
+
+
+typedef struct __attribute__ ((__packed__)) ICOHeader {
+    uint8_t width;
+    uint8_t height;
+    uint8_t colors_count;
+    uint8_t reserved;
+    uint16_t plans;
+    uint16_t bpp;
+    uint32_t bitmap_size;
+    uint32_t bitmap_offset;
+} ICOHeader;
+
+typedef struct __attribute__ ((__packed__)) ICOFileHeader {
+    uint16_t reserved;
+    uint16_t type;
+    uint16_t image_count;
+    ICOHeader directory[0];
+} ICOFileHeader;
+
+
+typedef struct Icon {
+    int width;
+    int height;
+    uint8_t* pixmap;
+    uint8_t* mask;
+} Icon;
+
+
+static Icon *init_icon(uint8_t *buf, size_t buf_size)
+{
+    ICOFileHeader *file_header;
+    int i;
+
+    uint8_t *buf_end = buf + buf_size;
+
+    if (buf_size < sizeof(ICOFileHeader)) {
+        ERROR("invalid source file");
+        return NULL;
+    }
+
+    file_header = (ICOFileHeader *)buf;
+
+    if (file_header->reserved != 0 || file_header->type != 1) {
+        ERROR("invalid icon");
+        return NULL;
+    }
+
+    if (sizeof(ICOFileHeader) + file_header->image_count * sizeof(ICOHeader) > buf_size) {
+        ERROR("invalid source file");
+    }
+
+    for (i = 0; i < file_header->image_count; i++) {
+        int j;
+
+        ICOHeader *ico = &file_header->directory[i];
+        printf("%ux%ux%u size %u\n", (unsigned)ico->width, (unsigned)ico->height,
+               (unsigned)ico->bpp, ico->bitmap_size);
+
+        if (ico->bitmap_offset + ico->bitmap_size > buf_size) {
+            ERROR("invalid source file");
+        }
+        BitmpaHeader *bitmap = (BitmpaHeader *)(buf + ico->bitmap_offset);
+        if (bitmap->header_size != 40) {
+            ERROR("invalid bitmap header");
+        }
+        if (bitmap->width != ico->width || bitmap->height != ico->height * 2 ||
+            bitmap->plans != ico->plans || bitmap->bpp != ico->bpp || !bitmap->image_size) {
+            ERROR("invalid bitmap header");
+        }
+
+        if (bitmap->compression || bitmap->horizontal_resolution || bitmap->vertical_resolution ||
+                                                   bitmap->num_colors || bitmap->important_colors) {
+            ERROR("invalid bitmap header");
+        }
+
+        if (ico->width != 32 || ico->height != 32 || ico->bpp != 32) {
+            continue;
+        }
+
+        int pixmap_size = bitmap->width * sizeof(uint32_t) * ico->height;
+        int mask_size = ALIGN(bitmap->width, 8) / 8 * ico->height;
+        Icon* icon = malloc(sizeof(*icon) + pixmap_size + mask_size);
+        icon->width = ico->width;
+        icon->height = ico->height;
+        icon->pixmap = (uint8_t *)(icon + 1);
+        icon->mask = icon->pixmap + pixmap_size;
+
+        if ((uint8_t *)(bitmap + 1) + pixmap_size + mask_size > buf_end) {
+            ERROR("invalid source file");
+        }
+        memcpy(icon->pixmap, bitmap + 1, pixmap_size);
+        memcpy(icon->mask, (uint8_t *)(bitmap + 1) + pixmap_size, mask_size);
+        for (j = 0; j < mask_size; j++) {
+            icon->mask[j] = ~icon->mask[j];
+        }
+        return icon;
+    }
+    printf("%s: missing 32x32x32\n", prog_name);
+    return NULL;
+}
+
+static inline void put_char(FILE* f, uint8_t val)
+{
+    fprintf(f, "0x%.2x,", val);
+}
+
+static int icon_to_c_struct(const Icon *icon, const char *dest_file, const char *image_name)
+{
+    int i, j;
+    int fd;
+    FILE *f;
+
+    if ((fd = open(dest_file, O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1) {
+        ERROR("open dest file failed");
+        return -1;
+    }
+
+    if (!(f = fdopen(fd, "w"))) {
+        ERROR("fdopen failed");
+        close(fd);
+        return -1;
+    }
+    uint32_t pixmap_stride = icon->width * sizeof(uint32_t);
+    uint32_t pixmap_size = pixmap_stride * icon->height;
+    uint32_t mask_stride = ALIGN(icon->width, 8) / 8;
+    uint32_t mask_size = mask_stride * icon->height;
+    fprintf(f, "static const struct {\n"
+               "\tuint32_t width;\n"
+               "\tuint32_t height;\n"
+               "\tuint8_t pixmap[%u];\n"
+               "\tuint8_t mask[%u];\n"
+               "} %s = { %u, %u, {",
+            pixmap_size, mask_size, image_name, icon->width, icon->height);
+
+    uint8_t *line = (uint8_t *)(icon->pixmap + ((icon->height - 1) * pixmap_stride));
+    int line_size = 0;
+
+    for (i = 0; i < icon->height; i++) {
+        uint8_t *now = line;
+        for (j = 0; j < icon->width; j++, now += 4) {
+            if ((line_size++ % 6) == 0) {
+                fprintf(f, "\n\t\t");
+            }
+            put_char(f, now[0]);
+            put_char(f, now[1]);
+            put_char(f, now[2]);
+            put_char(f, now[3]);
+        }
+        line -= pixmap_stride;
+    }
+
+
+    fseek(f, -1, SEEK_CUR);
+    fprintf(f, "},\n\n\t\t{");
+
+    line = (uint8_t *)(icon->mask + ((icon->height - 1) * mask_stride));
+    line_size = 0;
+    for (i = 0; i < icon->height; i++) {
+        for (j = 0; j < mask_stride; j++) {
+            if (line_size && (line_size % 12) == 0) {
+                fprintf(f, "\n\t\t ");
+            }
+            line_size++;
+            put_char(f, line[j]);
+        }
+        line -= mask_stride;
+    }
+
+    fseek(f, -1, SEEK_CUR);
+    fprintf(f, "}\n};\n");
+    fclose(f);
+    close(fd);
+    return 0;
+}
+
+enum {
+    HELP_OPT = 'h',
+    NAME_OPT = 'n',
+};
+
+static void usage()
+{
+    printf("usage: %s [--name <struct name>] SOURCE [DEST]\n", prog_name);
+    printf("       %s --help\n", prog_name);
+}
+
+const struct option longopts[] = {
+    {"help", no_argument, NULL, HELP_OPT},
+    {"name", required_argument, NULL, NAME_OPT},
+    {NULL, 0, NULL, 0},
+};
+
+int main(int argc, char **argv)
+{
+    size_t input_size;
+    uint8_t* buf;
+    Icon *icon;
+    int opt;
+    char *struct_name = NULL;
+    char *src = NULL;
+    char *dest = NULL;
+
+
+    if (!(prog_name = strrchr(argv[0], '/'))) {
+        prog_name = argv[0];
+    } else {
+        prog_name++;
+    }
+
+
+    while ((opt = getopt_long(argc, argv, "ah", longopts, NULL)) != -1) {
+        switch (opt) {
+        case 0:
+        case '?':
+            usage();
+            exit(-1);
+        case HELP_OPT:
+            usage();
+            exit(0);
+        case NAME_OPT:
+            struct_name = optarg;
+            break;
+        }
+    }
+
+    int more = argc - optind;
+    switch (more) {
+    case 1: {
+        char *slash;
+        char *dot;
+
+        dest = malloc(strlen(argv[optind]) + 3);
+        strcpy(dest, argv[optind]);
+        dot = strrchr(dest, '.');
+        slash = strrchr(dest, '/');
+        if (!dot || (slash && slash > dot)) {
+            strcat(dest, ".c");
+        } else {
+            strcpy(dot, ".c");
+        }
+        break;
+    }
+    case 2:
+        dest = argv[optind + 1];
+        //todo: if dir strcat src name
+        break;
+    default:
+        usage();
+        exit(-1);
+    }
+
+    src = argv[optind];
+
+    if (!struct_name) {
+        char *struct_name_src;
+        char *dot;
+
+        struct_name_src = strrchr(dest, '/');
+        if (!struct_name_src) {
+            struct_name_src = dest;
+        } else {
+            ++struct_name_src;
+        }
+        struct_name = malloc(strlen(struct_name_src) + 1);
+        strcpy(struct_name, struct_name_src);
+        if ((dot = strchr(struct_name, '.'))) {
+            *dot = 0;
+        }
+    }
+
+    if (!(input_size = read_input(src, &buf))) {
+        return -1;
+    }
+
+    if (!(icon = init_icon(buf, input_size))) {
+        return -1;
+    }
+
+    return icon_to_c_struct(icon, dest, struct_name);
+}
+
diff --git a/tools/reds_stat.c b/tools/reds_stat.c
new file mode 100644
index 00000000..76541579
--- /dev/null
+++ b/tools/reds_stat.c
@@ -0,0 +1,132 @@
+/*
+   Copyright (C) 2009 Red Hat, Inc.
+
+   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 of
+   the License, 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include "reds_stat.h"
+
+#define TAB_LEN 4
+#define VALUE_TABS 7
+#define INVALID_STAT_REF (~(uint32_t)0)
+
+static RedsStat *reds_stat = NULL;
+static uint64_t *values = NULL;
+
+void print_stat_tree(int32_t node_index, int depth)
+{
+    StatNode *node = &reds_stat->nodes[node_index];
+    int i;
+
+    if ((node->flags & STAT_NODE_MASK_SHOW) == STAT_NODE_MASK_SHOW) {
+        printf("%*s%s", depth * TAB_LEN, "", node->name);
+        if (node->flags & STAT_NODE_FLAG_VALUE) {
+            printf(":%*s%llu (%llu)\n", (VALUE_TABS - depth) * TAB_LEN - strlen(node->name) - 1, "",
+                   node->value, node->value - values[node_index]);
+            values[node_index] = node->value;
+        } else {
+            printf("\n");
+            if (node->first_child_index != INVALID_STAT_REF) {
+                print_stat_tree(node->first_child_index, depth + 1);
+            }
+        }
+    }
+    if (node->next_sibling_index != INVALID_STAT_REF) {
+        print_stat_tree(node->next_sibling_index, depth);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    char *shm_name;
+    pid_t kvm_pid;
+    uint64_t *val;
+    uint32_t num_of_nodes = 0;
+    size_t shm_size;
+    size_t shm_old_size;
+    int shm_name_len;
+    int ret = -1;
+    int fd;
+
+    if (argc != 2 || !(kvm_pid = atoi(argv[1]))) {
+        printf("usage: reds_stat [qemu_pid] (e.g. `pgrep qemu`)\n");
+        return -1;
+    }
+    shm_name_len = strlen(REDS_STAT_SHM_NAME) + strlen(argv[1]);
+    if (!(shm_name = (char *)malloc(shm_name_len))) {
+        perror("malloc");
+        return -1;
+    }
+    snprintf(shm_name, shm_name_len, REDS_STAT_SHM_NAME, kvm_pid);
+    if ((fd = shm_open(shm_name, O_RDONLY, 0444)) == -1) {
+        perror("shm_open");
+        free(shm_name);
+        return -1;
+    }
+    shm_size = sizeof(RedsStat);
+    reds_stat = mmap(NULL, shm_size, PROT_READ, MAP_SHARED, fd, 0);
+    if (reds_stat == (RedsStat *)MAP_FAILED) {
+        perror("mmap");
+        goto error1;
+    }
+    if (reds_stat->magic != REDS_STAT_MAGIC) {
+        printf("bad magic %u\n", reds_stat->magic);
+        goto error2;
+    }
+    if (reds_stat->version != REDS_STAT_VERSION) {
+        printf("bad version %u\n", reds_stat->version);
+        goto error2;
+    }
+    while (1) {
+        system("clear");
+        printf("spice statistics\n\n");
+        if (num_of_nodes != reds_stat->num_of_nodes) {
+            num_of_nodes = reds_stat->num_of_nodes;
+            shm_old_size = shm_size;
+            shm_size = sizeof(RedsStat) + num_of_nodes * sizeof(StatNode);
+            reds_stat = mremap(reds_stat, shm_old_size, shm_size, MREMAP_MAYMOVE);
+            if (reds_stat == (RedsStat *)MAP_FAILED) {
+                perror("mremap");
+                goto error3;
+            }
+            values = (uint64_t *)realloc(values, num_of_nodes * sizeof(uint64_t));
+            if (values == NULL) {
+                perror("realloc");
+                goto error3;
+            }
+            memset(values, 0, num_of_nodes * sizeof(uint64_t));
+        }
+        print_stat_tree(reds_stat->root_index, 0);
+        sleep(1);
+    }
+    ret = 0;
+
+error3:
+    free(values);
+error2:
+    munmap(reds_stat, shm_size);
+error1:
+    shm_unlink(shm_name);
+    free(shm_name);
+    return ret;
+}
+
diff --git a/uncrustify_cfg/uncrustify_stage1.cfg b/uncrustify_cfg/uncrustify_stage1.cfg
new file mode 100644
index 00000000..6ce2e9dc
--- /dev/null
+++ b/uncrustify_cfg/uncrustify_stage1.cfg
@@ -0,0 +1,245 @@
+# Uncrustify 0.53
+indent_align_string=false
+indent_braces=false
+indent_braces_no_func=false
+indent_brace_parent=false
+indent_namespace=false
+indent_extern=false
+indent_class=true
+indent_class_colon=false
+indent_else_if=false
+indent_func_call_param=false
+indent_func_def_param=false
+indent_func_proto_param=false
+indent_func_class_param=false
+indent_func_ctor_var_param=false
+indent_template_param=false
+indent_func_param_double=false
+indent_relative_single_line_comments=false
+indent_col1_comment=false
+indent_access_spec_body=false
+indent_paren_nl=false
+indent_comma_paren=false
+indent_bool_paren=false
+indent_square_nl=false
+indent_preserve_sql=false
+indent_align_assign=false
+sp_balance_nested_parens=false
+align_keep_tabs=false
+align_with_tabs=false
+align_on_tabstop=false
+align_number_left=false
+align_func_params=false
+align_same_func_call_params=false
+align_var_def_colon=false
+align_var_def_attribute=false
+align_var_def_inline=false
+align_right_cmt_mix=false
+align_on_operator=false
+align_mix_var_proto=false
+align_single_line_func=false
+align_single_line_brace=false
+align_nl_cont=false
+align_left_shift=true
+nl_collapse_empty_body=false
+nl_assign_leave_one_liners=true
+nl_class_leave_one_liners=true
+nl_enum_leave_one_liners=true
+nl_getset_leave_one_liners=true
+nl_func_leave_one_liners=false
+nl_if_leave_one_liners=false
+nl_multi_line_cond=false
+nl_multi_line_define=true
+nl_before_case=false
+nl_after_case=false
+nl_after_return=false
+nl_after_semicolon=true
+nl_after_brace_open=false
+nl_after_brace_open_cmt=false
+nl_after_vbrace_open=false
+nl_after_brace_close=false
+nl_define_macro=false
+nl_squeeze_ifdef=false
+nl_ds_struct_enum_cmt=false
+nl_ds_struct_enum_close_brace=false
+nl_create_if_one_liner=false
+nl_create_for_one_liner=false
+nl_create_while_one_liner=false
+ls_for_split_full=false
+ls_func_split_full=false
+nl_after_multiline_comment=false
+eat_blanks_after_open_brace=true
+eat_blanks_before_close_brace=true
+mod_pawn_semicolon=false
+mod_full_paren_if_bool=false
+mod_remove_extra_semicolon=true
+mod_sort_import=false
+mod_sort_using=false
+mod_sort_include=false
+mod_move_case_break=true
+mod_remove_empty_return=true
+cmt_indent_multi=false
+cmt_c_group=false
+cmt_c_nl_start=false
+cmt_c_nl_end=false
+cmt_cpp_group=false
+cmt_cpp_nl_start=false
+cmt_cpp_nl_end=false
+cmt_cpp_to_c=false
+cmt_star_cont=false
+cmt_multi_check_last=true
+cmt_insert_before_preproc=false
+pp_indent_at_level=false
+pp_region_indent_code=false
+pp_if_indent_code=false
+pp_define_at_level=false
+input_tab_size=4
+indent_columns=4
+nl_after_func_body=2
+nl_before_access_spec=2
+newlines=LF
+indent_with_tabs=0
+sp_arith=force
+sp_assign=force
+sp_enum_assign=force
+sp_enum_before_assign=force
+sp_enum_after_assign=force
+sp_pp_concat=ignore
+sp_pp_stringify=ignore
+sp_bool=force
+sp_compare=force
+sp_inside_paren=remove
+sp_paren_paren=remove
+sp_paren_brace=force
+sp_before_ptr_star=ignore
+sp_before_unnamed_ptr_star=ignore
+sp_between_ptr_star=remove
+sp_after_ptr_star=ignore
+sp_after_ptr_star_func=ignore
+sp_before_ptr_star_func=ignore
+sp_before_byref=ignore
+sp_before_unnamed_byref=ignore
+sp_after_byref=ignore
+sp_after_byref_func=ignore
+sp_before_byref_func=ignore
+sp_after_type=force
+sp_before_sparen=force
+sp_inside_sparen=remove
+sp_after_sparen=force
+sp_sparen_brace=force
+sp_special_semi=remove
+sp_before_semi=remove
+sp_before_semi_for=remove
+sp_before_semi_for_empty=remove
+sp_after_semi_for_empty=remove
+sp_before_square=remove
+sp_before_squares=remove
+sp_inside_square=remove
+sp_after_comma=force
+sp_before_comma=remove
+sp_after_class_colon=force
+sp_before_class_colon=remove
+sp_before_case_colon=remove
+sp_after_operator=force
+sp_after_operator_sym=force
+sp_after_cast=remove
+sp_inside_paren_cast=remove
+sp_cpp_cast_paren=remove
+sp_sizeof_paren=remove
+sp_type_func=ignore
+sp_func_proto_paren=remove
+sp_func_def_paren=remove
+sp_inside_fparens=remove
+sp_inside_fparen=remove
+sp_square_fparen=remove
+sp_fparen_brace=force
+sp_func_call_paren=remove
+sp_func_class_paren=remove
+sp_return_paren=force
+sp_attribute_paren=force
+sp_defined_paren=remove
+sp_throw_paren=force
+sp_macro=force
+sp_macro_func=force
+sp_else_brace=force
+sp_brace_else=force
+sp_brace_typedef=force
+sp_catch_brace=force
+sp_brace_catch=force
+sp_finally_brace=force
+sp_brace_finally=force
+sp_try_brace=force
+sp_getset_brace=force
+sp_before_dc=remove
+sp_after_dc=remove
+sp_not=remove
+sp_inv=remove
+sp_addr=remove
+sp_member=remove
+sp_deref=remove
+sp_sign=remove
+sp_incdec=remove
+sp_before_nl_cont=ignore
+sp_cond_colon=force
+sp_cond_question=force
+sp_case_label=remove
+nl_start_of_file=remove
+nl_end_of_file=add
+nl_assign_brace=remove
+nl_assign_square=remove
+nl_fcall_brace=ignore
+nl_enum_brace=remove
+nl_struct_brace=remove
+nl_union_brace=remove
+nl_if_brace=remove
+nl_brace_else=remove
+nl_elseif_brace=remove
+nl_else_brace=remove
+nl_else_if=remove
+nl_brace_finally=remove
+nl_finally_brace=remove
+nl_try_brace=remove
+nl_getset_brace=remove
+nl_for_brace=remove
+nl_catch_brace=remove
+nl_brace_catch=remove
+nl_while_brace=remove
+nl_do_brace=remove
+nl_brace_while=remove
+nl_switch_brace=remove
+nl_before_throw=add
+nl_namespace_brace=remove
+nl_template_class=add
+nl_class_brace=remove
+nl_class_init_args=add
+nl_func_type_name=remove
+nl_func_scope_name=remove
+nl_func_proto_type_name=remove
+nl_func_paren=remove
+nl_func_decl_start=remove
+nl_func_decl_args=ignore
+nl_func_decl_end=remove
+nl_fdef_brace=add
+nl_return_expr=remove
+nl_before_if=ignore
+nl_after_if=ignore
+nl_before_for=ignore
+nl_after_for=ignore
+nl_before_while=ignore
+nl_after_while=ignore
+nl_before_switch=ignore
+nl_after_switch=ignore
+nl_before_do=ignore
+nl_after_do=ignore
+nl_class_colon=ignore
+pos_arith=trail
+pos_assign=trail
+pos_bool=trail
+pos_comma=trail
+pos_class_comma=lead
+pos_class_colon=lead
+mod_full_brace_do=add
+mod_full_brace_for=add
+mod_full_brace_function=add
+mod_full_brace_if=add
+mod_full_brace_while=add
diff --git a/uncrustify_cfg/uncrustify_stage2_c.cfg b/uncrustify_cfg/uncrustify_stage2_c.cfg
new file mode 100644
index 00000000..9cc58996
--- /dev/null
+++ b/uncrustify_cfg/uncrustify_stage2_c.cfg
@@ -0,0 +1,245 @@
+# Uncrustify 0.53
+indent_align_string=false
+indent_braces=false
+indent_braces_no_func=false
+indent_brace_parent=false
+indent_namespace=false
+indent_extern=false
+indent_class=true
+indent_class_colon=false
+indent_else_if=false
+indent_func_call_param=false
+indent_func_def_param=false
+indent_func_proto_param=false
+indent_func_class_param=false
+indent_func_ctor_var_param=false
+indent_template_param=false
+indent_func_param_double=false
+indent_relative_single_line_comments=false
+indent_col1_comment=false
+indent_access_spec_body=false
+indent_paren_nl=false
+indent_comma_paren=false
+indent_bool_paren=false
+indent_square_nl=false
+indent_preserve_sql=false
+indent_align_assign=false
+sp_balance_nested_parens=false
+align_keep_tabs=false
+align_with_tabs=false
+align_on_tabstop=false
+align_number_left=false
+align_func_params=false
+align_same_func_call_params=false
+align_var_def_colon=false
+align_var_def_attribute=false
+align_var_def_inline=false
+align_right_cmt_mix=false
+align_on_operator=false
+align_mix_var_proto=false
+align_single_line_func=false
+align_single_line_brace=false
+align_nl_cont=false
+align_left_shift=true
+nl_collapse_empty_body=false
+nl_assign_leave_one_liners=true
+nl_class_leave_one_liners=true
+nl_enum_leave_one_liners=true
+nl_getset_leave_one_liners=true
+nl_func_leave_one_liners=false
+nl_if_leave_one_liners=false
+nl_multi_line_cond=false
+nl_multi_line_define=true
+nl_before_case=false
+nl_after_case=false
+nl_after_return=false
+nl_after_semicolon=true
+nl_after_brace_open=false
+nl_after_brace_open_cmt=false
+nl_after_vbrace_open=false
+nl_after_brace_close=false
+nl_define_macro=false
+nl_squeeze_ifdef=false
+nl_ds_struct_enum_cmt=false
+nl_ds_struct_enum_close_brace=false
+nl_create_if_one_liner=false
+nl_create_for_one_liner=false
+nl_create_while_one_liner=false
+ls_for_split_full=false
+ls_func_split_full=false
+nl_after_multiline_comment=false
+eat_blanks_after_open_brace=true
+eat_blanks_before_close_brace=true
+mod_pawn_semicolon=false
+mod_full_paren_if_bool=false
+mod_remove_extra_semicolon=true
+mod_sort_import=false
+mod_sort_using=false
+mod_sort_include=false
+mod_move_case_break=true
+mod_remove_empty_return=true
+cmt_indent_multi=false
+cmt_c_group=false
+cmt_c_nl_start=false
+cmt_c_nl_end=false
+cmt_cpp_group=false
+cmt_cpp_nl_start=false
+cmt_cpp_nl_end=false
+cmt_cpp_to_c=false
+cmt_star_cont=false
+cmt_multi_check_last=true
+cmt_insert_before_preproc=false
+pp_indent_at_level=false
+pp_region_indent_code=false
+pp_if_indent_code=false
+pp_define_at_level=false
+input_tab_size=4
+indent_columns=4
+nl_after_func_body=2
+nl_before_access_spec=2
+newlines=LF
+indent_with_tabs=0
+sp_arith=force
+sp_assign=force
+sp_enum_assign=force
+sp_enum_before_assign=force
+sp_enum_after_assign=force
+sp_pp_concat=ignore
+sp_pp_stringify=ignore
+sp_bool=force
+sp_compare=force
+sp_inside_paren=remove
+sp_paren_paren=remove
+sp_paren_brace=force
+sp_before_ptr_star=force
+sp_before_unnamed_ptr_star=ignore
+sp_between_ptr_star=remove
+sp_after_ptr_star=remove
+sp_after_ptr_star_func=remove
+sp_before_ptr_star_func=force
+sp_before_byref=force
+sp_before_unnamed_byref=ignore
+sp_after_byref=remove
+sp_after_byref_func=remove
+sp_before_byref_func=force
+sp_after_type=force
+sp_before_sparen=force
+sp_inside_sparen=remove
+sp_after_sparen=force
+sp_sparen_brace=force
+sp_special_semi=remove
+sp_before_semi=remove
+sp_before_semi_for=remove
+sp_before_semi_for_empty=remove
+sp_after_semi_for_empty=remove
+sp_before_square=remove
+sp_before_squares=remove
+sp_inside_square=remove
+sp_after_comma=force
+sp_before_comma=remove
+sp_after_class_colon=ignore
+sp_before_class_colon=ignore
+sp_before_case_colon=remove
+sp_after_operator=force
+sp_after_operator_sym=force
+sp_after_cast=remove
+sp_inside_paren_cast=remove
+sp_cpp_cast_paren=remove
+sp_sizeof_paren=remove
+sp_type_func=ignore
+sp_func_proto_paren=remove
+sp_func_def_paren=remove
+sp_inside_fparens=remove
+sp_inside_fparen=remove
+sp_square_fparen=remove
+sp_fparen_brace=force
+sp_func_call_paren=ignore
+sp_func_class_paren=remove
+sp_return_paren=force
+sp_attribute_paren=force
+sp_defined_paren=remove
+sp_throw_paren=force
+sp_macro=force
+sp_macro_func=force
+sp_else_brace=force
+sp_brace_else=force
+sp_brace_typedef=force
+sp_catch_brace=force
+sp_brace_catch=force
+sp_finally_brace=force
+sp_brace_finally=force
+sp_try_brace=force
+sp_getset_brace=force
+sp_before_dc=remove
+sp_after_dc=remove
+sp_not=remove
+sp_inv=remove
+sp_addr=remove
+sp_member=remove
+sp_deref=remove
+sp_sign=remove
+sp_incdec=remove
+sp_before_nl_cont=ignore
+sp_cond_colon=force
+sp_cond_question=force
+sp_case_label=remove
+nl_start_of_file=remove
+nl_end_of_file=add
+nl_assign_brace=remove
+nl_assign_square=remove
+nl_fcall_brace=ignore
+nl_enum_brace=remove
+nl_struct_brace=remove
+nl_union_brace=remove
+nl_if_brace=remove
+nl_brace_else=remove
+nl_elseif_brace=remove
+nl_else_brace=remove
+nl_else_if=remove
+nl_brace_finally=remove
+nl_finally_brace=remove
+nl_try_brace=remove
+nl_getset_brace=remove
+nl_for_brace=remove
+nl_catch_brace=remove
+nl_brace_catch=remove
+nl_while_brace=remove
+nl_do_brace=remove
+nl_brace_while=remove
+nl_switch_brace=remove
+nl_before_throw=add
+nl_namespace_brace=remove
+nl_template_class=add
+nl_class_brace=remove
+nl_class_init_args=add
+nl_func_type_name=remove
+nl_func_scope_name=remove
+nl_func_proto_type_name=remove
+nl_func_paren=remove
+nl_func_decl_start=remove
+nl_func_decl_args=ignore
+nl_func_decl_end=remove
+nl_fdef_brace=add
+nl_return_expr=remove
+nl_before_if=ignore
+nl_after_if=ignore
+nl_before_for=ignore
+nl_after_for=ignore
+nl_before_while=ignore
+nl_after_while=ignore
+nl_before_switch=ignore
+nl_after_switch=ignore
+nl_before_do=ignore
+nl_after_do=ignore
+nl_class_colon=ignore
+pos_arith=trail
+pos_assign=trail
+pos_bool=trail
+pos_comma=trail
+pos_class_comma=lead
+pos_class_colon=lead
+mod_full_brace_do=add
+mod_full_brace_for=add
+mod_full_brace_function=add
+mod_full_brace_if=add
+mod_full_brace_while=add
diff --git a/uncrustify_cfg/uncrustify_stage2_cpp.cfg b/uncrustify_cfg/uncrustify_stage2_cpp.cfg
new file mode 100644
index 00000000..8552d4a7
--- /dev/null
+++ b/uncrustify_cfg/uncrustify_stage2_cpp.cfg
@@ -0,0 +1,245 @@
+# Uncrustify 0.53
+indent_align_string=false
+indent_braces=false
+indent_braces_no_func=false
+indent_brace_parent=false
+indent_namespace=false
+indent_extern=false
+indent_class=true
+indent_class_colon=false
+indent_else_if=false
+indent_func_call_param=false
+indent_func_def_param=false
+indent_func_proto_param=false
+indent_func_class_param=false
+indent_func_ctor_var_param=false
+indent_template_param=false
+indent_func_param_double=false
+indent_relative_single_line_comments=false
+indent_col1_comment=false
+indent_access_spec_body=false
+indent_paren_nl=false
+indent_comma_paren=false
+indent_bool_paren=false
+indent_square_nl=false
+indent_preserve_sql=false
+indent_align_assign=false
+sp_balance_nested_parens=false
+align_keep_tabs=false
+align_with_tabs=false
+align_on_tabstop=false
+align_number_left=false
+align_func_params=false
+align_same_func_call_params=false
+align_var_def_colon=false
+align_var_def_attribute=false
+align_var_def_inline=false
+align_right_cmt_mix=false
+align_on_operator=false
+align_mix_var_proto=false
+align_single_line_func=false
+align_single_line_brace=false
+align_nl_cont=false
+align_left_shift=true
+nl_collapse_empty_body=false
+nl_assign_leave_one_liners=true
+nl_class_leave_one_liners=true
+nl_enum_leave_one_liners=true
+nl_getset_leave_one_liners=true
+nl_func_leave_one_liners=false
+nl_if_leave_one_liners=false
+nl_multi_line_cond=false
+nl_multi_line_define=true
+nl_before_case=false
+nl_after_case=false
+nl_after_return=false
+nl_after_semicolon=true
+nl_after_brace_open=false
+nl_after_brace_open_cmt=false
+nl_after_vbrace_open=false
+nl_after_brace_close=false
+nl_define_macro=false
+nl_squeeze_ifdef=false
+nl_ds_struct_enum_cmt=false
+nl_ds_struct_enum_close_brace=false
+nl_create_if_one_liner=false
+nl_create_for_one_liner=false
+nl_create_while_one_liner=false
+ls_for_split_full=false
+ls_func_split_full=false
+nl_after_multiline_comment=false
+eat_blanks_after_open_brace=true
+eat_blanks_before_close_brace=true
+mod_pawn_semicolon=false
+mod_full_paren_if_bool=false
+mod_remove_extra_semicolon=true
+mod_sort_import=false
+mod_sort_using=false
+mod_sort_include=false
+mod_move_case_break=true
+mod_remove_empty_return=true
+cmt_indent_multi=false
+cmt_c_group=false
+cmt_c_nl_start=false
+cmt_c_nl_end=false
+cmt_cpp_group=false
+cmt_cpp_nl_start=false
+cmt_cpp_nl_end=false
+cmt_cpp_to_c=false
+cmt_star_cont=false
+cmt_multi_check_last=true
+cmt_insert_before_preproc=false
+pp_indent_at_level=false
+pp_region_indent_code=false
+pp_if_indent_code=false
+pp_define_at_level=false
+input_tab_size=4
+indent_columns=4
+nl_after_func_body=2
+nl_before_access_spec=2
+newlines=LF
+indent_with_tabs=0
+sp_arith=force
+sp_assign=force
+sp_enum_assign=force
+sp_enum_before_assign=force
+sp_enum_after_assign=force
+sp_pp_concat=ignore
+sp_pp_stringify=ignore
+sp_bool=force
+sp_compare=force
+sp_inside_paren=remove
+sp_paren_paren=remove
+sp_paren_brace=force
+sp_before_ptr_star=remove
+sp_before_unnamed_ptr_star=ignore
+sp_between_ptr_star=remove
+sp_after_ptr_star=force
+sp_after_ptr_star_func=force
+sp_before_ptr_star_func=remove
+sp_before_byref=remove
+sp_before_unnamed_byref=ignore
+sp_after_byref=force
+sp_after_byref_func=force
+sp_before_byref_func=remove
+sp_after_type=force
+sp_before_sparen=force
+sp_inside_sparen=remove
+sp_after_sparen=force
+sp_sparen_brace=force
+sp_special_semi=remove
+sp_before_semi=remove
+sp_before_semi_for=remove
+sp_before_semi_for_empty=remove
+sp_after_semi_for_empty=remove
+sp_before_square=remove
+sp_before_squares=remove
+sp_inside_square=remove
+sp_after_comma=force
+sp_before_comma=remove
+sp_after_class_colon=ignore
+sp_before_class_colon=ignore
+sp_before_case_colon=remove
+sp_after_operator=force
+sp_after_operator_sym=force
+sp_after_cast=remove
+sp_inside_paren_cast=remove
+sp_cpp_cast_paren=remove
+sp_sizeof_paren=remove
+sp_type_func=ignore
+sp_func_proto_paren=remove
+sp_func_def_paren=remove
+sp_inside_fparens=remove
+sp_inside_fparen=remove
+sp_square_fparen=remove
+sp_fparen_brace=force
+sp_func_call_paren=ignore
+sp_func_class_paren=remove
+sp_return_paren=force
+sp_attribute_paren=force
+sp_defined_paren=remove
+sp_throw_paren=force
+sp_macro=force
+sp_macro_func=force
+sp_else_brace=force
+sp_brace_else=force
+sp_brace_typedef=force
+sp_catch_brace=force
+sp_brace_catch=force
+sp_finally_brace=force
+sp_brace_finally=force
+sp_try_brace=force
+sp_getset_brace=force
+sp_before_dc=remove
+sp_after_dc=remove
+sp_not=remove
+sp_inv=remove
+sp_addr=remove
+sp_member=remove
+sp_deref=remove
+sp_sign=remove
+sp_incdec=remove
+sp_before_nl_cont=ignore
+sp_cond_colon=force
+sp_cond_question=force
+sp_case_label=remove
+nl_start_of_file=remove
+nl_end_of_file=add
+nl_assign_brace=remove
+nl_assign_square=remove
+nl_fcall_brace=ignore
+nl_enum_brace=remove
+nl_struct_brace=remove
+nl_union_brace=remove
+nl_if_brace=remove
+nl_brace_else=remove
+nl_elseif_brace=remove
+nl_else_brace=remove
+nl_else_if=remove
+nl_brace_finally=remove
+nl_finally_brace=remove
+nl_try_brace=remove
+nl_getset_brace=remove
+nl_for_brace=remove
+nl_catch_brace=remove
+nl_brace_catch=remove
+nl_while_brace=remove
+nl_do_brace=remove
+nl_brace_while=remove
+nl_switch_brace=remove
+nl_before_throw=add
+nl_namespace_brace=remove
+nl_template_class=add
+nl_class_brace=remove
+nl_class_init_args=add
+nl_func_type_name=remove
+nl_func_scope_name=remove
+nl_func_proto_type_name=remove
+nl_func_paren=remove
+nl_func_decl_start=remove
+nl_func_decl_args=ignore
+nl_func_decl_end=remove
+nl_fdef_brace=add
+nl_return_expr=remove
+nl_before_if=ignore
+nl_after_if=ignore
+nl_before_for=ignore
+nl_after_for=ignore
+nl_before_while=ignore
+nl_after_while=ignore
+nl_before_switch=ignore
+nl_after_switch=ignore
+nl_before_do=ignore
+nl_after_do=ignore
+nl_class_colon=ignore
+pos_arith=trail
+pos_assign=trail
+pos_bool=trail
+pos_comma=trail
+pos_class_comma=lead
+pos_class_colon=lead
+mod_full_brace_do=add
+mod_full_brace_for=add
+mod_full_brace_function=add
+mod_full_brace_if=add
+mod_full_brace_while=add