From 84182d94ca80994729ce514a2be0648615f72d28 Mon Sep 17 00:00:00 2001 From: 4am Date: Fri, 25 Oct 2019 09:14:25 -0400 Subject: [PATCH] some wipes --- res/fx.conf | 2 +- res/notes/transitions/slowripple.py | 17 + src/fx/fx.hgr.corner4.in.a | 14 + src/fx/fx.hgr.corner4.in.data.a | 6720 +++++++++++++++++++++++++++ src/fx/fx.hgr.corner4.out.a | 14 + src/fx/fx.hgr.corner4.out.data.a | 6720 +++++++++++++++++++++++++++ src/fx/fx.hgr.precomputed.1bit.a | 2 +- 7 files changed, 13487 insertions(+), 2 deletions(-) create mode 100644 src/fx/fx.hgr.corner4.in.a create mode 100644 src/fx/fx.hgr.corner4.in.data.a create mode 100644 src/fx/fx.hgr.corner4.out.a create mode 100644 src/fx/fx.hgr.corner4.out.data.a diff --git a/res/fx.conf b/res/fx.conf index e66388657..24be42458 100644 --- a/res/fx.conf +++ b/res/fx.conf @@ -1 +1 @@ -RIPPLE STARWHITE SOFT.DIAGONAL STAGGERWHITE.UD RADIAL STAGGER.LR SOFT.UD CRYSTAL BIT.FIZZLE MEETINTHEMIDDLE DIAGONAL R.BY.PIXEL SUNRISE SOFT.L SUNSET IRIS.IN CORNER.CIRCLE CENTER.BY.PIXEL DIAGONAL2 RIPPLE2 PALETTE.FIZZLE RADIAL2 SPLIT.UD.INTRO R.BY.2 HALF.FIZZLE RADIAL3 DIAGONAL3 BAR.DISSOLVE R.BY.PALETTE FOURSPIRAL SOFT.R IRIS CASCADE AND CHECKERBOARD LR.BY.PIXEL RADIAL4 CHECKER.FIZZLE STAGGERWHITE.LR SOFT.UD.OUT ONESQUARE FIZZLE STAR DIAMOND TWOPASS.LR HALF.MOSAIC RADIAL5 ARROW FOURSQUARE DIAGONAL4 STAGGER.UD INTERLOCK.LR SOFT.UD.IN BLOCK.MOSAIC INTERLOCK.UD BLOCK.FIZZLE SPIRAL ARROW.WHITE [eof] # # transition effects for HGR slideshows # # Each Mega-Attract Module that is an HGR slideshow (see attract.conf) # will use a single transition effect for the length of the module. # Transition effects are loaded in the order listed in this file. Each line # of this file is a filename (not including comments, like this one). The # name of the next transition effect is stored in the global prefs, so this # file should not contain duplicates. # # Transition effects are binary files loaded at $6000 and called with # hi-res page 1 showing and the next HGR graphic already loaded at $4000. # A transition effect can use $6000-$BFFF in main memory, zero page, and # text page if needed (but preserve the screen holes). $800-$1FFF is reserved # for the slideshow data. LC RAM banks 1 and 2 are reserved for the launcher. # # Important: LC RAM bank 1 will be read/write on entry and must be read/write # on exit. If you need ROM routines, you are responsible for switching to ROM # then switching back to RAM bank 1 (read/write) before returning. # \ No newline at end of file +RIPPLE STARWHITE SOFT.DIAGONAL STAGGERWHITE.UD RADIAL STAGGER.LR SOFT.UD CRYSTAL BIT.FIZZLE MEETINTHEMIDDLE DIAGONAL R.BY.PIXEL SUNRISE SOFT.L SUNSET IRIS.IN CORNER.CIRCLE CENTER.BY.PIXEL DIAGONAL2 RIPPLE2 PALETTE.FIZZLE RADIAL2 SPLIT.UD.INTRO R.BY.2 HALF.FIZZLE RADIAL3 DIAGONAL3 CORNER4.OUT BAR.DISSOLVE R.BY.PALETTE FOURSPIRAL SOFT.R IRIS CASCADE AND CHECKERBOARD LR.BY.PIXEL RADIAL4 CHECKER.FIZZLE STAGGERWHITE.LR SOFT.UD.OUT ONESQUARE FIZZLE STAR DIAMOND TWOPASS.LR HALF.MOSAIC RADIAL5 ARROW FOURSQUARE DIAGONAL4 STAGGER.UD INTERLOCK.LR SOFT.UD.IN BLOCK.MOSAIC CORNER4.IN INTERLOCK.UD BLOCK.FIZZLE SPIRAL ARROW.WHITE [eof] # # transition effects for HGR slideshows # # Each Mega-Attract Module that is an HGR slideshow (see attract.conf) # will use a single transition effect for the length of the module. # Transition effects are loaded in the order listed in this file. Each line # of this file is a filename (not including comments, like this one). The # name of the next transition effect is stored in the global prefs, so this # file should not contain duplicates. # # Transition effects are binary files loaded at $6000 and called with # hi-res page 1 showing and the next HGR graphic already loaded at $4000. # A transition effect can use $6000-$BFFF in main memory, zero page, and # text page if needed (but preserve the screen holes). $800-$1FFF is reserved # for the slideshow data. LC RAM banks 1 and 2 are reserved for the launcher. # # Important: LC RAM bank 1 will be read/write on entry and must be read/write # on exit. If you need ROM routines, you are responsible for switching to ROM # then switching back to RAM bank 1 (read/write) before returning. # \ No newline at end of file diff --git a/res/notes/transitions/slowripple.py b/res/notes/transitions/slowripple.py index 4627c2854..5ee409c08 100755 --- a/res/notes/transitions/slowripple.py +++ b/res/notes/transitions/slowripple.py @@ -54,3 +54,20 @@ for i, j, k, l in zip(range(1680), range(1680,3360), range(3360,5040), range(504 with open("../../../src/fx/fx.hgr.ripple.data.a", "w") as f: for aval, bval in ripple_vals: f.write(" !byte %s,%s\n" % (aval, bval)) + +corner4_vals = [] +for x, y in unique_coords: + x = 139-x + y = 95-y + aval = "$" + hex(y)[2:].rjust(2, "0").upper() + bval = "%" + \ + bin(x%7)[2:].rjust(3, "0") + \ + bin(x//7)[2:].rjust(5, "0") + corner4_vals.append((aval, bval)) +with open("../../../src/fx/fx.hgr.corner4.in.data.a", "w") as f: + for aval, bval in corner4_vals: + f.write(" !byte %s,%s\n" % (aval, bval)) +corner4_vals.reverse() +with open("../../../src/fx/fx.hgr.corner4.out.data.a", "w") as f: + for aval, bval in corner4_vals: + f.write(" !byte %s,%s\n" % (aval, bval)) diff --git a/src/fx/fx.hgr.corner4.in.a b/src/fx/fx.hgr.corner4.in.a new file mode 100644 index 000000000..57011fd34 --- /dev/null +++ b/src/fx/fx.hgr.corner4.in.a @@ -0,0 +1,14 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/CORNER4.IN",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + + +FX_PRECOMPUTED_1BIT Coordinates + +Coordinates + !source "src/fx/fx.hgr.corner4.in.data.a" + !byte $80 diff --git a/src/fx/fx.hgr.corner4.in.data.a b/src/fx/fx.hgr.corner4.in.data.a new file mode 100644 index 000000000..3f43b7213 --- /dev/null +++ b/src/fx/fx.hgr.corner4.in.data.a @@ -0,0 +1,6720 @@ + !byte $01,%00100000 + !byte $01,%00000000 + !byte $01,%01000000 + !byte $01,%01100000 + !byte $03,%00100000 + !byte $03,%00000000 + !byte $01,%10000000 + !byte $03,%01100000 + !byte $03,%01000000 + !byte $01,%10100000 + !byte $03,%10000000 + !byte $05,%00100000 + !byte $05,%00000000 + !byte $01,%11000000 + !byte $03,%10100000 + !byte $05,%01100000 + !byte $05,%01000000 + !byte $01,%00000001 + !byte $03,%00000001 + !byte $03,%11000000 + !byte $05,%10100000 + !byte $05,%10000000 + !byte $07,%00000000 + !byte $01,%00100001 + !byte $03,%00100001 + !byte $05,%11000000 + !byte $07,%01100000 + !byte $07,%01000000 + !byte $07,%00100000 + !byte $01,%01000001 + !byte $03,%01000001 + !byte $05,%00100001 + !byte $05,%00000001 + !byte $07,%10100000 + !byte $07,%10000000 + !byte $01,%01100001 + !byte $03,%01100001 + !byte $05,%01000001 + !byte $07,%00000001 + !byte $07,%11000000 + !byte $09,%01100000 + !byte $09,%01000000 + !byte $09,%00100000 + !byte $09,%00000000 + !byte $01,%10000001 + !byte $03,%10000001 + !byte $05,%01100001 + !byte $07,%00100001 + !byte $09,%10100000 + !byte $09,%10000000 + !byte $01,%10100001 + !byte $03,%10100001 + !byte $05,%10000001 + !byte $07,%01000001 + !byte $09,%00000001 + !byte $09,%11000000 + !byte $0B,%01100000 + !byte $0B,%01000000 + !byte $0B,%00100000 + !byte $0B,%00000000 + !byte $01,%11000001 + !byte $03,%11000001 + !byte $05,%10100001 + !byte $07,%10000001 + !byte $07,%01100001 + !byte $09,%01000001 + !byte $09,%00100001 + !byte $0B,%10100000 + !byte $0B,%10000000 + !byte $01,%00000010 + !byte $03,%00000010 + !byte $05,%11000001 + !byte $07,%10100001 + !byte $09,%01100001 + !byte $0B,%00000001 + !byte $0B,%11000000 + !byte $0D,%00100000 + !byte $0D,%00000000 + !byte $01,%00100010 + !byte $03,%00100010 + !byte $05,%00000010 + !byte $07,%11000001 + !byte $09,%10000001 + !byte $0B,%01000001 + !byte $0B,%00100001 + !byte $0D,%10100000 + !byte $0D,%10000000 + !byte $0D,%01100000 + !byte $0D,%01000000 + !byte $01,%01000010 + !byte $03,%01000010 + !byte $05,%00100010 + !byte $07,%00000010 + !byte $09,%11000001 + !byte $09,%10100001 + !byte $0B,%10000001 + !byte $0B,%01100001 + !byte $0D,%00000001 + !byte $0D,%11000000 + !byte $01,%01100010 + !byte $03,%01100010 + !byte $05,%01000010 + !byte $07,%00100010 + !byte $09,%00000010 + !byte $0B,%10100001 + !byte $0D,%01000001 + !byte $0D,%00100001 + !byte $0F,%10000000 + !byte $0F,%01100000 + !byte $0F,%01000000 + !byte $0F,%00100000 + !byte $0F,%00000000 + !byte $01,%10000010 + !byte $03,%10000010 + !byte $05,%01100010 + !byte $07,%01100010 + !byte $07,%01000010 + !byte $09,%00100010 + !byte $0B,%11000001 + !byte $0D,%10000001 + !byte $0D,%01100001 + !byte $0F,%00000001 + !byte $0F,%11000000 + !byte $0F,%10100000 + !byte $01,%10100010 + !byte $03,%10100010 + !byte $05,%10100010 + !byte $05,%10000010 + !byte $07,%10000010 + !byte $09,%01000010 + !byte $0B,%00100010 + !byte $0B,%00000010 + !byte $0D,%10100001 + !byte $0F,%01000001 + !byte $0F,%00100001 + !byte $11,%10000000 + !byte $11,%01100000 + !byte $11,%01000000 + !byte $11,%00100000 + !byte $11,%00000000 + !byte $01,%11000010 + !byte $03,%11000010 + !byte $05,%11000010 + !byte $07,%10100010 + !byte $09,%10000010 + !byte $09,%01100010 + !byte $0B,%01000010 + !byte $0D,%00000010 + !byte $0D,%11000001 + !byte $0F,%10000001 + !byte $0F,%01100001 + !byte $11,%00000001 + !byte $11,%11000000 + !byte $11,%10100000 + !byte $01,%00000011 + !byte $03,%00000011 + !byte $05,%00000011 + !byte $07,%11000010 + !byte $09,%10100010 + !byte $0B,%01100010 + !byte $0D,%00100010 + !byte $0F,%11000001 + !byte $0F,%10100001 + !byte $11,%01000001 + !byte $11,%00100001 + !byte $13,%01100000 + !byte $13,%01000000 + !byte $13,%00100000 + !byte $13,%00000000 + !byte $01,%00100011 + !byte $03,%00100011 + !byte $05,%00100011 + !byte $07,%00000011 + !byte $09,%11000010 + !byte $0B,%10000010 + !byte $0D,%01100010 + !byte $0D,%01000010 + !byte $0F,%00000010 + !byte $11,%10000001 + !byte $11,%01100001 + !byte $13,%00000001 + !byte $13,%11000000 + !byte $13,%10100000 + !byte $13,%10000000 + !byte $01,%01000011 + !byte $03,%01000011 + !byte $05,%01000011 + !byte $07,%00100011 + !byte $09,%00000011 + !byte $0B,%11000010 + !byte $0B,%10100010 + !byte $0D,%10000010 + !byte $0F,%01000010 + !byte $0F,%00100010 + !byte $11,%11000001 + !byte $11,%10100001 + !byte $13,%01000001 + !byte $13,%00100001 + !byte $15,%00000000 + !byte $01,%01100011 + !byte $03,%01100011 + !byte $05,%01100011 + !byte $07,%01000011 + !byte $09,%00100011 + !byte $0B,%00000011 + !byte $0D,%10100010 + !byte $0F,%01100010 + !byte $11,%00100010 + !byte $11,%00000010 + !byte $13,%10100001 + !byte $13,%10000001 + !byte $13,%01100001 + !byte $15,%11000000 + !byte $15,%10100000 + !byte $15,%10000000 + !byte $15,%01100000 + !byte $15,%01000000 + !byte $15,%00100000 + !byte $01,%10000011 + !byte $03,%10000011 + !byte $05,%10000011 + !byte $07,%01100011 + !byte $09,%01000011 + !byte $0B,%00100011 + !byte $0D,%11000010 + !byte $0F,%10100010 + !byte $0F,%10000010 + !byte $11,%01000010 + !byte $13,%11000001 + !byte $15,%01000001 + !byte $15,%00100001 + !byte $15,%00000001 + !byte $01,%10100011 + !byte $03,%10100011 + !byte $05,%10100011 + !byte $07,%10000011 + !byte $09,%01100011 + !byte $0B,%01000011 + !byte $0D,%00100011 + !byte $0D,%00000011 + !byte $0F,%11000010 + !byte $11,%10000010 + !byte $11,%01100010 + !byte $13,%00100010 + !byte $13,%00000010 + !byte $15,%10000001 + !byte $15,%01100001 + !byte $17,%10100000 + !byte $17,%10000000 + !byte $17,%01100000 + !byte $17,%01000000 + !byte $17,%00100000 + !byte $17,%00000000 + !byte $01,%11000011 + !byte $03,%11000011 + !byte $05,%11000011 + !byte $07,%10100011 + !byte $09,%10000011 + !byte $0B,%01100011 + !byte $0D,%01000011 + !byte $0F,%00000011 + !byte $11,%10100010 + !byte $13,%01100010 + !byte $13,%01000010 + !byte $15,%11000001 + !byte $15,%10100001 + !byte $17,%00100001 + !byte $17,%00000001 + !byte $17,%11000000 + !byte $01,%00000100 + !byte $03,%00000100 + !byte $05,%00000100 + !byte $07,%11000011 + !byte $09,%10100011 + !byte $0B,%10000011 + !byte $0D,%01100011 + !byte $0F,%00100011 + !byte $11,%00000011 + !byte $11,%11000010 + !byte $13,%10000010 + !byte $15,%00100010 + !byte $15,%00000010 + !byte $17,%10000001 + !byte $17,%01100001 + !byte $17,%01000001 + !byte $19,%10000000 + !byte $19,%01100000 + !byte $19,%01000000 + !byte $19,%00100000 + !byte $19,%00000000 + !byte $01,%00100100 + !byte $03,%00100100 + !byte $05,%00100100 + !byte $07,%00000100 + !byte $09,%11000011 + !byte $0B,%11000011 + !byte $0B,%10100011 + !byte $0D,%10000011 + !byte $0F,%01100011 + !byte $0F,%01000011 + !byte $11,%00100011 + !byte $13,%11000010 + !byte $13,%10100010 + !byte $15,%01100010 + !byte $15,%01000010 + !byte $17,%11000001 + !byte $17,%10100001 + !byte $19,%00100001 + !byte $19,%00000001 + !byte $19,%11000000 + !byte $19,%10100000 + !byte $01,%01000100 + !byte $03,%01000100 + !byte $05,%01000100 + !byte $07,%00100100 + !byte $09,%00100100 + !byte $09,%00000100 + !byte $0B,%00000100 + !byte $0D,%10100011 + !byte $0F,%10000011 + !byte $11,%01000011 + !byte $13,%00000011 + !byte $15,%10100010 + !byte $15,%10000010 + !byte $17,%00100010 + !byte $17,%00000010 + !byte $19,%10000001 + !byte $19,%01100001 + !byte $19,%01000001 + !byte $1B,%01000000 + !byte $1B,%00100000 + !byte $1B,%00000000 + !byte $01,%01100100 + !byte $03,%01100100 + !byte $05,%01100100 + !byte $07,%01000100 + !byte $09,%01000100 + !byte $0B,%00100100 + !byte $0D,%00000100 + !byte $0D,%11000011 + !byte $0F,%10100011 + !byte $11,%10000011 + !byte $11,%01100011 + !byte $13,%00100011 + !byte $15,%11000010 + !byte $17,%01100010 + !byte $17,%01000010 + !byte $19,%11000001 + !byte $19,%10100001 + !byte $1B,%00000001 + !byte $1B,%11000000 + !byte $1B,%10100000 + !byte $1B,%10000000 + !byte $1B,%01100000 + !byte $01,%10000100 + !byte $03,%10000100 + !byte $05,%10000100 + !byte $07,%01100100 + !byte $09,%01100100 + !byte $0B,%01000100 + !byte $0D,%00100100 + !byte $0F,%11000011 + !byte $11,%10100011 + !byte $13,%01100011 + !byte $13,%01000011 + !byte $15,%00100011 + !byte $15,%00000011 + !byte $17,%10100010 + !byte $17,%10000010 + !byte $19,%00100010 + !byte $19,%00000010 + !byte $1B,%10000001 + !byte $1B,%01100001 + !byte $1B,%01000001 + !byte $1B,%00100001 + !byte $01,%10100100 + !byte $03,%10100100 + !byte $05,%10100100 + !byte $07,%10000100 + !byte $09,%10000100 + !byte $0B,%01100100 + !byte $0D,%01000100 + !byte $0F,%00000100 + !byte $11,%11000011 + !byte $13,%10000011 + !byte $15,%01000011 + !byte $17,%00000011 + !byte $17,%11000010 + !byte $19,%01100010 + !byte $19,%01000010 + !byte $1B,%11000001 + !byte $1B,%10100001 + !byte $1D,%11000000 + !byte $1D,%10100000 + !byte $1D,%10000000 + !byte $1D,%01100000 + !byte $1D,%01000000 + !byte $1D,%00100000 + !byte $1D,%00000000 + !byte $01,%11000100 + !byte $03,%11000100 + !byte $05,%11000100 + !byte $07,%10100100 + !byte $09,%10100100 + !byte $0B,%10000100 + !byte $0D,%01100100 + !byte $0F,%01000100 + !byte $0F,%00100100 + !byte $11,%00000100 + !byte $13,%11000011 + !byte $13,%10100011 + !byte $15,%01100011 + !byte $17,%00100011 + !byte $19,%10100010 + !byte $19,%10000010 + !byte $1B,%00100010 + !byte $1B,%00000010 + !byte $1D,%01100001 + !byte $1D,%01000001 + !byte $1D,%00100001 + !byte $1D,%00000001 + !byte $01,%00000101 + !byte $03,%00000101 + !byte $05,%00000101 + !byte $07,%11000100 + !byte $09,%11000100 + !byte $0B,%10100100 + !byte $0D,%10000100 + !byte $0F,%01100100 + !byte $11,%00100100 + !byte $13,%00000100 + !byte $15,%10100011 + !byte $15,%10000011 + !byte $17,%01100011 + !byte $17,%01000011 + !byte $19,%00000011 + !byte $19,%11000010 + !byte $1B,%01100010 + !byte $1B,%01000010 + !byte $1D,%11000001 + !byte $1D,%10100001 + !byte $1D,%10000001 + !byte $1F,%10100000 + !byte $1F,%10000000 + !byte $1F,%01100000 + !byte $1F,%01000000 + !byte $1F,%00100000 + !byte $1F,%00000000 + !byte $01,%00100101 + !byte $03,%00100101 + !byte $05,%00100101 + !byte $07,%00000101 + !byte $09,%00000101 + !byte $0B,%11000100 + !byte $0D,%10100100 + !byte $0F,%10000100 + !byte $11,%01100100 + !byte $11,%01000100 + !byte $13,%00100100 + !byte $15,%11000011 + !byte $17,%10000011 + !byte $19,%00100011 + !byte $1B,%10100010 + !byte $1B,%10000010 + !byte $1D,%00100010 + !byte $1D,%00000010 + !byte $1F,%01000001 + !byte $1F,%00100001 + !byte $1F,%00000001 + !byte $1F,%11000000 + !byte $01,%01000101 + !byte $03,%01000101 + !byte $05,%01000101 + !byte $07,%01000101 + !byte $07,%00100101 + !byte $09,%00100101 + !byte $0B,%00000101 + !byte $0D,%11000100 + !byte $0F,%10100100 + !byte $11,%10000100 + !byte $13,%01000100 + !byte $15,%00100100 + !byte $15,%00000100 + !byte $17,%11000011 + !byte $17,%10100011 + !byte $19,%01100011 + !byte $19,%01000011 + !byte $1B,%00000011 + !byte $1B,%11000010 + !byte $1D,%10000010 + !byte $1D,%01100010 + !byte $1D,%01000010 + !byte $1F,%10100001 + !byte $1F,%10000001 + !byte $1F,%01100001 + !byte $21,%01100000 + !byte $21,%01000000 + !byte $21,%00100000 + !byte $21,%00000000 + !byte $01,%01100101 + !byte $03,%01100101 + !byte $05,%01100101 + !byte $07,%01100101 + !byte $09,%01000101 + !byte $0B,%00100101 + !byte $0D,%00000101 + !byte $0F,%11000100 + !byte $11,%10100100 + !byte $13,%10000100 + !byte $13,%01100100 + !byte $15,%01000100 + !byte $17,%00000100 + !byte $19,%10100011 + !byte $19,%10000011 + !byte $1B,%01000011 + !byte $1B,%00100011 + !byte $1D,%10100010 + !byte $1F,%00100010 + !byte $1F,%00000010 + !byte $1F,%11000001 + !byte $21,%01000001 + !byte $21,%00100001 + !byte $21,%00000001 + !byte $21,%11000000 + !byte $21,%10100000 + !byte $21,%10000000 + !byte $01,%10000101 + !byte $03,%10000101 + !byte $05,%10000101 + !byte $07,%10000101 + !byte $09,%01100101 + !byte $0B,%01000101 + !byte $0D,%00100101 + !byte $0F,%00000101 + !byte $11,%11000100 + !byte $13,%10100100 + !byte $15,%01100100 + !byte $17,%00100100 + !byte $19,%11000011 + !byte $1B,%01100011 + !byte $1D,%00000011 + !byte $1D,%11000010 + !byte $1F,%01100010 + !byte $1F,%01000010 + !byte $21,%10100001 + !byte $21,%10000001 + !byte $21,%01100001 + !byte $01,%10100101 + !byte $03,%10100101 + !byte $05,%10100101 + !byte $07,%10100101 + !byte $09,%10000101 + !byte $0B,%01100101 + !byte $0D,%01000101 + !byte $0F,%00100101 + !byte $11,%00000101 + !byte $13,%11000100 + !byte $15,%10000100 + !byte $17,%01100100 + !byte $17,%01000100 + !byte $19,%00100100 + !byte $19,%00000100 + !byte $1B,%10100011 + !byte $1B,%10000011 + !byte $1D,%01000011 + !byte $1D,%00100011 + !byte $1F,%11000010 + !byte $1F,%10100010 + !byte $1F,%10000010 + !byte $21,%00100010 + !byte $21,%00000010 + !byte $21,%11000001 + !byte $23,%00100001 + !byte $23,%00000001 + !byte $23,%11000000 + !byte $23,%10100000 + !byte $23,%10000000 + !byte $23,%01100000 + !byte $23,%01000000 + !byte $23,%00100000 + !byte $23,%00000000 + !byte $01,%11000101 + !byte $03,%11000101 + !byte $05,%11000101 + !byte $07,%11000101 + !byte $09,%10100101 + !byte $0B,%10000101 + !byte $0D,%10000101 + !byte $0D,%01100101 + !byte $0F,%01100101 + !byte $0F,%01000101 + !byte $11,%00100101 + !byte $13,%00000101 + !byte $15,%11000100 + !byte $15,%10100100 + !byte $17,%10000100 + !byte $19,%01000100 + !byte $1B,%00000100 + !byte $1B,%11000011 + !byte $1D,%10000011 + !byte $1D,%01100011 + !byte $1F,%00100011 + !byte $1F,%00000011 + !byte $21,%01100010 + !byte $21,%01000010 + !byte $23,%10100001 + !byte $23,%10000001 + !byte $23,%01100001 + !byte $23,%01000001 + !byte $01,%00000110 + !byte $03,%00000110 + !byte $05,%00000110 + !byte $07,%00000110 + !byte $09,%11000101 + !byte $0B,%10100101 + !byte $0D,%10100101 + !byte $0F,%10000101 + !byte $11,%01100101 + !byte $11,%01000101 + !byte $13,%00100101 + !byte $15,%00000101 + !byte $17,%10100100 + !byte $19,%01100100 + !byte $1B,%00100100 + !byte $1D,%10100011 + !byte $1F,%01000011 + !byte $21,%10100010 + !byte $21,%10000010 + !byte $23,%00100010 + !byte $23,%00000010 + !byte $23,%11000001 + !byte $25,%11000000 + !byte $25,%10100000 + !byte $25,%10000000 + !byte $25,%01100000 + !byte $25,%01000000 + !byte $25,%00100000 + !byte $25,%00000000 + !byte $01,%00100110 + !byte $03,%00100110 + !byte $05,%00100110 + !byte $07,%00100110 + !byte $09,%00000110 + !byte $0B,%11000101 + !byte $0D,%11000101 + !byte $0F,%10100101 + !byte $11,%10000101 + !byte $13,%01000101 + !byte $15,%00100101 + !byte $17,%11000100 + !byte $19,%10000100 + !byte $1B,%01000100 + !byte $1D,%00000100 + !byte $1D,%11000011 + !byte $1F,%10000011 + !byte $1F,%01100011 + !byte $21,%00000011 + !byte $21,%11000010 + !byte $23,%01100010 + !byte $23,%01000010 + !byte $25,%10000001 + !byte $25,%01100001 + !byte $25,%01000001 + !byte $25,%00100001 + !byte $25,%00000001 + !byte $01,%01000110 + !byte $03,%01000110 + !byte $05,%01000110 + !byte $07,%01000110 + !byte $09,%00100110 + !byte $0B,%00100110 + !byte $0B,%00000110 + !byte $0D,%00000110 + !byte $0F,%11000101 + !byte $11,%10100101 + !byte $13,%10000101 + !byte $13,%01100101 + !byte $15,%01000101 + !byte $17,%00100101 + !byte $17,%00000101 + !byte $19,%11000100 + !byte $19,%10100100 + !byte $1B,%10000100 + !byte $1B,%01100100 + !byte $1D,%01000100 + !byte $1D,%00100100 + !byte $1F,%11000011 + !byte $1F,%10100011 + !byte $21,%01000011 + !byte $21,%00100011 + !byte $23,%10100010 + !byte $23,%10000010 + !byte $25,%00000010 + !byte $25,%11000001 + !byte $25,%10100001 + !byte $27,%10000000 + !byte $27,%01100000 + !byte $27,%01000000 + !byte $27,%00100000 + !byte $27,%00000000 + !byte $01,%01100110 + !byte $03,%01100110 + !byte $05,%01100110 + !byte $07,%01100110 + !byte $09,%01000110 + !byte $0B,%01000110 + !byte $0D,%00100110 + !byte $0F,%00000110 + !byte $11,%11000101 + !byte $13,%10100101 + !byte $15,%01100101 + !byte $17,%01000101 + !byte $19,%00000101 + !byte $1B,%10100100 + !byte $1D,%01100100 + !byte $1F,%00000100 + !byte $21,%10000011 + !byte $21,%01100011 + !byte $23,%00000011 + !byte $23,%11000010 + !byte $25,%01100010 + !byte $25,%01000010 + !byte $25,%00100010 + !byte $27,%01100001 + !byte $27,%01000001 + !byte $27,%00100001 + !byte $27,%00000001 + !byte $27,%11000000 + !byte $27,%10100000 + !byte $01,%10000110 + !byte $03,%10000110 + !byte $05,%10000110 + !byte $07,%10000110 + !byte $09,%01100110 + !byte $0B,%01100110 + !byte $0D,%01000110 + !byte $0F,%00100110 + !byte $11,%00000110 + !byte $13,%11000101 + !byte $15,%10100101 + !byte $15,%10000101 + !byte $17,%01100101 + !byte $19,%00100101 + !byte $1B,%11000100 + !byte $1D,%10000100 + !byte $1F,%01000100 + !byte $1F,%00100100 + !byte $21,%11000011 + !byte $21,%10100011 + !byte $23,%01000011 + !byte $23,%00100011 + !byte $25,%10100010 + !byte $25,%10000010 + !byte $27,%11000001 + !byte $27,%10100001 + !byte $27,%10000001 + !byte $29,%00100000 + !byte $29,%00000000 + !byte $01,%10100110 + !byte $03,%10100110 + !byte $05,%10100110 + !byte $07,%10100110 + !byte $09,%10000110 + !byte $0B,%10000110 + !byte $0D,%01100110 + !byte $0F,%01000110 + !byte $11,%00100110 + !byte $13,%00000110 + !byte $15,%11000101 + !byte $17,%10000101 + !byte $19,%01100101 + !byte $19,%01000101 + !byte $1B,%00100101 + !byte $1B,%00000101 + !byte $1D,%11000100 + !byte $1D,%10100100 + !byte $1F,%01100100 + !byte $21,%00100100 + !byte $21,%00000100 + !byte $23,%10000011 + !byte $23,%01100011 + !byte $25,%00100011 + !byte $25,%00000011 + !byte $25,%11000010 + !byte $27,%01000010 + !byte $27,%00100010 + !byte $27,%00000010 + !byte $29,%01000001 + !byte $29,%00100001 + !byte $29,%00000001 + !byte $29,%11000000 + !byte $29,%10100000 + !byte $29,%10000000 + !byte $29,%01100000 + !byte $29,%01000000 + !byte $01,%11000110 + !byte $03,%11000110 + !byte $05,%11000110 + !byte $07,%11000110 + !byte $09,%10100110 + !byte $0B,%10100110 + !byte $0D,%10000110 + !byte $0F,%01100110 + !byte $11,%01000110 + !byte $13,%00100110 + !byte $15,%00000110 + !byte $17,%10100101 + !byte $19,%10000101 + !byte $1B,%01000101 + !byte $1D,%00000101 + !byte $1F,%10100100 + !byte $1F,%10000100 + !byte $21,%01000100 + !byte $23,%11000011 + !byte $23,%10100011 + !byte $25,%01100011 + !byte $25,%01000011 + !byte $27,%10100010 + !byte $27,%10000010 + !byte $27,%01100010 + !byte $29,%11000001 + !byte $29,%10100001 + !byte $29,%10000001 + !byte $29,%01100001 + !byte $01,%00000111 + !byte $03,%00000111 + !byte $05,%00000111 + !byte $07,%00000111 + !byte $09,%11000110 + !byte $0B,%11000110 + !byte $0D,%10100110 + !byte $0F,%10000110 + !byte $11,%01100110 + !byte $13,%01000110 + !byte $15,%00100110 + !byte $17,%00000110 + !byte $17,%11000101 + !byte $19,%10100101 + !byte $1B,%01100101 + !byte $1D,%01000101 + !byte $1D,%00100101 + !byte $1F,%11000100 + !byte $21,%10000100 + !byte $21,%01100100 + !byte $23,%00100100 + !byte $23,%00000100 + !byte $25,%10000011 + !byte $27,%00000011 + !byte $27,%11000010 + !byte $29,%01000010 + !byte $29,%00100010 + !byte $29,%00000010 + !byte $2B,%00000001 + !byte $2B,%11000000 + !byte $2B,%10100000 + !byte $2B,%10000000 + !byte $2B,%01100000 + !byte $2B,%01000000 + !byte $2B,%00100000 + !byte $2B,%00000000 + !byte $01,%00100111 + !byte $03,%00100111 + !byte $05,%00100111 + !byte $07,%00100111 + !byte $09,%00000111 + !byte $0B,%00000111 + !byte $0D,%11000110 + !byte $0F,%10100110 + !byte $11,%10000110 + !byte $13,%01100110 + !byte $15,%01000110 + !byte $17,%00100110 + !byte $19,%11000101 + !byte $1B,%10100101 + !byte $1B,%10000101 + !byte $1D,%01100101 + !byte $1F,%00100101 + !byte $1F,%00000101 + !byte $21,%10100100 + !byte $23,%01000100 + !byte $25,%11000011 + !byte $25,%10100011 + !byte $27,%01100011 + !byte $27,%01000011 + !byte $27,%00100011 + !byte $29,%10100010 + !byte $29,%10000010 + !byte $29,%01100010 + !byte $2B,%10100001 + !byte $2B,%10000001 + !byte $2B,%01100001 + !byte $2B,%01000001 + !byte $2B,%00100001 + !byte $01,%01000111 + !byte $03,%01000111 + !byte $05,%01000111 + !byte $07,%01000111 + !byte $09,%00100111 + !byte $0B,%00100111 + !byte $0D,%00000111 + !byte $0F,%11000110 + !byte $11,%10100110 + !byte $13,%10000110 + !byte $15,%01100110 + !byte $17,%01000110 + !byte $19,%00100110 + !byte $19,%00000110 + !byte $1B,%11000101 + !byte $1D,%10000101 + !byte $1F,%01000101 + !byte $21,%00000101 + !byte $21,%11000100 + !byte $23,%10000100 + !byte $23,%01100100 + !byte $25,%00100100 + !byte $25,%00000100 + !byte $27,%10100011 + !byte $27,%10000011 + !byte $29,%00000011 + !byte $29,%11000010 + !byte $2B,%01000010 + !byte $2B,%00100010 + !byte $2B,%00000010 + !byte $2B,%11000001 + !byte $2D,%10100000 + !byte $2D,%10000000 + !byte $2D,%01100000 + !byte $2D,%01000000 + !byte $2D,%00100000 + !byte $2D,%00000000 + !byte $01,%01100111 + !byte $03,%01100111 + !byte $05,%01100111 + !byte $07,%01100111 + !byte $09,%01000111 + !byte $0B,%01000111 + !byte $0D,%00100111 + !byte $0F,%00000111 + !byte $11,%00000111 + !byte $11,%11000110 + !byte $13,%11000110 + !byte $13,%10100110 + !byte $15,%10000110 + !byte $17,%01100110 + !byte $19,%01000110 + !byte $1B,%00000110 + !byte $1D,%10100101 + !byte $1F,%10000101 + !byte $1F,%01100101 + !byte $21,%00100101 + !byte $23,%11000100 + !byte $23,%10100100 + !byte $25,%01100100 + !byte $25,%01000100 + !byte $27,%11000011 + !byte $29,%01000011 + !byte $29,%00100011 + !byte $2B,%10100010 + !byte $2B,%10000010 + !byte $2B,%01100010 + !byte $2D,%10000001 + !byte $2D,%01100001 + !byte $2D,%01000001 + !byte $2D,%00100001 + !byte $2D,%00000001 + !byte $2D,%11000000 + !byte $01,%10000111 + !byte $03,%10000111 + !byte $05,%10000111 + !byte $07,%10000111 + !byte $09,%01100111 + !byte $0B,%01100111 + !byte $0D,%01000111 + !byte $0F,%00100111 + !byte $11,%00100111 + !byte $13,%00000111 + !byte $15,%11000110 + !byte $15,%10100110 + !byte $17,%10000110 + !byte $19,%01100110 + !byte $1B,%00100110 + !byte $1D,%00000110 + !byte $1D,%11000101 + !byte $1F,%10100101 + !byte $21,%01100101 + !byte $21,%01000101 + !byte $23,%00000101 + !byte $25,%10000100 + !byte $27,%00100100 + !byte $27,%00000100 + !byte $29,%10100011 + !byte $29,%10000011 + !byte $29,%01100011 + !byte $2B,%00000011 + !byte $2B,%11000010 + !byte $2D,%00100010 + !byte $2D,%00000010 + !byte $2D,%11000001 + !byte $2D,%10100001 + !byte $2F,%01100000 + !byte $2F,%01000000 + !byte $2F,%00100000 + !byte $2F,%00000000 + !byte $01,%10100111 + !byte $03,%10100111 + !byte $05,%10100111 + !byte $07,%10100111 + !byte $09,%10000111 + !byte $0B,%10000111 + !byte $0D,%01100111 + !byte $0F,%01100111 + !byte $0F,%01000111 + !byte $11,%01000111 + !byte $13,%00100111 + !byte $15,%00000111 + !byte $17,%10100110 + !byte $19,%10000110 + !byte $1B,%01100110 + !byte $1B,%01000110 + !byte $1D,%00100110 + !byte $1F,%11000101 + !byte $21,%10000101 + !byte $23,%01000101 + !byte $23,%00100101 + !byte $25,%11000100 + !byte $25,%10100100 + !byte $27,%01100100 + !byte $27,%01000100 + !byte $29,%00000100 + !byte $29,%11000011 + !byte $2B,%01000011 + !byte $2B,%00100011 + !byte $2D,%10000010 + !byte $2D,%01100010 + !byte $2D,%01000010 + !byte $2F,%01100001 + !byte $2F,%01000001 + !byte $2F,%00100001 + !byte $2F,%00000001 + !byte $2F,%11000000 + !byte $2F,%10100000 + !byte $2F,%10000000 + !byte $01,%11000111 + !byte $03,%11000111 + !byte $05,%11000111 + !byte $07,%11000111 + !byte $09,%10100111 + !byte $0B,%10100111 + !byte $0D,%10000111 + !byte $0F,%10000111 + !byte $11,%01100111 + !byte $13,%01000111 + !byte $15,%00100111 + !byte $17,%00000111 + !byte $17,%11000110 + !byte $19,%10100110 + !byte $1B,%10000110 + !byte $1D,%01000110 + !byte $1F,%00000110 + !byte $21,%10100101 + !byte $23,%01100101 + !byte $25,%00100101 + !byte $25,%00000101 + !byte $27,%10100100 + !byte $27,%10000100 + !byte $29,%01000100 + !byte $29,%00100100 + !byte $2B,%10000011 + !byte $2B,%01100011 + !byte $2D,%00000011 + !byte $2D,%11000010 + !byte $2D,%10100010 + !byte $2F,%00000010 + !byte $2F,%11000001 + !byte $2F,%10100001 + !byte $2F,%10000001 + !byte $01,%00001000 + !byte $03,%00001000 + !byte $05,%00001000 + !byte $07,%00001000 + !byte $09,%11000111 + !byte $0B,%11000111 + !byte $0D,%10100111 + !byte $0F,%10100111 + !byte $11,%10000111 + !byte $13,%01100111 + !byte $15,%01000111 + !byte $17,%00100111 + !byte $19,%11000110 + !byte $1B,%10100110 + !byte $1D,%10000110 + !byte $1D,%01100110 + !byte $1F,%01000110 + !byte $1F,%00100110 + !byte $21,%00000110 + !byte $21,%11000101 + !byte $23,%10100101 + !byte $23,%10000101 + !byte $25,%01000101 + !byte $27,%11000100 + !byte $29,%01100100 + !byte $2B,%00000100 + !byte $2B,%11000011 + !byte $2B,%10100011 + !byte $2D,%01000011 + !byte $2D,%00100011 + !byte $2F,%01100010 + !byte $2F,%01000010 + !byte $2F,%00100010 + !byte $31,%01000001 + !byte $31,%00100001 + !byte $31,%00000001 + !byte $31,%11000000 + !byte $31,%10100000 + !byte $31,%10000000 + !byte $31,%01100000 + !byte $31,%01000000 + !byte $31,%00100000 + !byte $31,%00000000 + !byte $01,%00101000 + !byte $03,%00101000 + !byte $05,%00101000 + !byte $07,%00101000 + !byte $09,%00001000 + !byte $0B,%00001000 + !byte $0D,%11000111 + !byte $0F,%11000111 + !byte $11,%10100111 + !byte $13,%10000111 + !byte $15,%01100111 + !byte $17,%01000111 + !byte $19,%00100111 + !byte $19,%00000111 + !byte $1B,%11000110 + !byte $1D,%10100110 + !byte $1F,%01100110 + !byte $21,%00100110 + !byte $23,%11000101 + !byte $25,%10000101 + !byte $25,%01100101 + !byte $27,%00100101 + !byte $27,%00000101 + !byte $29,%10100100 + !byte $29,%10000100 + !byte $2B,%01000100 + !byte $2B,%00100100 + !byte $2D,%10100011 + !byte $2D,%10000011 + !byte $2D,%01100011 + !byte $2F,%11000010 + !byte $2F,%10100010 + !byte $2F,%10000010 + !byte $31,%11000001 + !byte $31,%10100001 + !byte $31,%10000001 + !byte $31,%01100001 + !byte $01,%01001000 + !byte $03,%01001000 + !byte $05,%01001000 + !byte $07,%01001000 + !byte $09,%00101000 + !byte $0B,%00101000 + !byte $0D,%00001000 + !byte $0F,%00001000 + !byte $11,%11000111 + !byte $13,%10100111 + !byte $15,%10000111 + !byte $17,%01100111 + !byte $19,%01000111 + !byte $1B,%00000111 + !byte $1D,%11000110 + !byte $1F,%10000110 + !byte $21,%01000110 + !byte $23,%00000110 + !byte $25,%10100101 + !byte $27,%01100101 + !byte $27,%01000101 + !byte $29,%00000101 + !byte $29,%11000100 + !byte $2B,%10000100 + !byte $2B,%01100100 + !byte $2D,%11000011 + !byte $2F,%01000011 + !byte $2F,%00100011 + !byte $2F,%00000011 + !byte $31,%01100010 + !byte $31,%01000010 + !byte $31,%00100010 + !byte $31,%00000010 + !byte $33,%00000001 + !byte $33,%11000000 + !byte $33,%10100000 + !byte $33,%10000000 + !byte $33,%01100000 + !byte $33,%01000000 + !byte $33,%00100000 + !byte $33,%00000000 + !byte $01,%01101000 + !byte $03,%01101000 + !byte $05,%01101000 + !byte $07,%01101000 + !byte $09,%01101000 + !byte $09,%01001000 + !byte $0B,%01001000 + !byte $0D,%00101000 + !byte $0F,%00101000 + !byte $11,%00001000 + !byte $13,%11000111 + !byte $15,%10100111 + !byte $17,%10000111 + !byte $19,%01100111 + !byte $1B,%01000111 + !byte $1B,%00100111 + !byte $1D,%00000111 + !byte $1F,%11000110 + !byte $1F,%10100110 + !byte $21,%10000110 + !byte $21,%01100110 + !byte $23,%01000110 + !byte $23,%00100110 + !byte $25,%00000110 + !byte $25,%11000101 + !byte $27,%10000101 + !byte $29,%00100101 + !byte $2B,%10100100 + !byte $2D,%01000100 + !byte $2D,%00100100 + !byte $2D,%00000100 + !byte $2F,%10000011 + !byte $2F,%01100011 + !byte $31,%11000010 + !byte $31,%10100010 + !byte $31,%10000010 + !byte $33,%10100001 + !byte $33,%10000001 + !byte $33,%01100001 + !byte $33,%01000001 + !byte $33,%00100001 + !byte $01,%10001000 + !byte $03,%10001000 + !byte $05,%10001000 + !byte $07,%10001000 + !byte $09,%10001000 + !byte $0B,%01101000 + !byte $0D,%01101000 + !byte $0D,%01001000 + !byte $0F,%01001000 + !byte $11,%00101000 + !byte $13,%00001000 + !byte $15,%11000111 + !byte $17,%10100111 + !byte $19,%10000111 + !byte $1B,%01100111 + !byte $1D,%00100111 + !byte $1F,%00000111 + !byte $21,%10100110 + !byte $23,%01100110 + !byte $25,%00100110 + !byte $27,%11000101 + !byte $27,%10100101 + !byte $29,%01100101 + !byte $29,%01000101 + !byte $2B,%00000101 + !byte $2B,%11000100 + !byte $2D,%10000100 + !byte $2D,%01100100 + !byte $2F,%00000100 + !byte $2F,%11000011 + !byte $2F,%10100011 + !byte $31,%01000011 + !byte $31,%00100011 + !byte $31,%00000011 + !byte $33,%01000010 + !byte $33,%00100010 + !byte $33,%00000010 + !byte $33,%11000001 + !byte $35,%10000000 + !byte $35,%01100000 + !byte $35,%01000000 + !byte $35,%00100000 + !byte $35,%00000000 + !byte $01,%10101000 + !byte $03,%10101000 + !byte $05,%10101000 + !byte $07,%10101000 + !byte $09,%10101000 + !byte $0B,%10001000 + !byte $0D,%10001000 + !byte $0F,%01101000 + !byte $11,%01001000 + !byte $13,%00101000 + !byte $15,%00001000 + !byte $17,%11000111 + !byte $19,%10100111 + !byte $1B,%10000111 + !byte $1D,%01100111 + !byte $1D,%01000111 + !byte $1F,%00100111 + !byte $21,%11000110 + !byte $23,%10000110 + !byte $25,%01000110 + !byte $27,%00000110 + !byte $29,%10100101 + !byte $29,%10000101 + !byte $2B,%01000101 + !byte $2B,%00100101 + !byte $2D,%10100100 + !byte $2F,%01000100 + !byte $2F,%00100100 + !byte $31,%10000011 + !byte $31,%01100011 + !byte $33,%11000010 + !byte $33,%10100010 + !byte $33,%10000010 + !byte $33,%01100010 + !byte $35,%10000001 + !byte $35,%01100001 + !byte $35,%01000001 + !byte $35,%00100001 + !byte $35,%00000001 + !byte $35,%11000000 + !byte $35,%10100000 + !byte $01,%11001000 + !byte $03,%11001000 + !byte $05,%11001000 + !byte $07,%11001000 + !byte $09,%11001000 + !byte $0B,%10101000 + !byte $0D,%10101000 + !byte $0F,%10001000 + !byte $11,%01101000 + !byte $13,%01001000 + !byte $15,%00101000 + !byte $17,%00001000 + !byte $19,%11000111 + !byte $1B,%10100111 + !byte $1D,%10000111 + !byte $1F,%01000111 + !byte $21,%00000111 + !byte $23,%11000110 + !byte $23,%10100110 + !byte $25,%10000110 + !byte $25,%01100110 + !byte $27,%00100110 + !byte $29,%11000101 + !byte $2B,%01100101 + !byte $2D,%00000101 + !byte $2D,%11000100 + !byte $2F,%01100100 + !byte $31,%11000011 + !byte $31,%10100011 + !byte $33,%00100011 + !byte $33,%00000011 + !byte $35,%01000010 + !byte $35,%00100010 + !byte $35,%00000010 + !byte $35,%11000001 + !byte $35,%10100001 + !byte $01,%00001001 + !byte $03,%00001001 + !byte $05,%00001001 + !byte $07,%00001001 + !byte $09,%00001001 + !byte $0B,%11001000 + !byte $0D,%11001000 + !byte $0F,%10101000 + !byte $11,%10001000 + !byte $13,%01101000 + !byte $15,%01101000 + !byte $15,%01001000 + !byte $17,%01001000 + !byte $17,%00101000 + !byte $19,%00001000 + !byte $1B,%11000111 + !byte $1D,%10100111 + !byte $1F,%01100111 + !byte $21,%01000111 + !byte $21,%00100111 + !byte $23,%00000111 + !byte $25,%10100110 + !byte $27,%01100110 + !byte $27,%01000110 + !byte $29,%00000110 + !byte $2B,%10100101 + !byte $2B,%10000101 + !byte $2D,%01000101 + !byte $2D,%00100101 + !byte $2F,%10100100 + !byte $2F,%10000100 + !byte $31,%01000100 + !byte $31,%00100100 + !byte $31,%00000100 + !byte $33,%10000011 + !byte $33,%01100011 + !byte $33,%01000011 + !byte $35,%10100010 + !byte $35,%10000010 + !byte $35,%01100010 + !byte $37,%01100001 + !byte $37,%01000001 + !byte $37,%00100001 + !byte $37,%00000001 + !byte $37,%11000000 + !byte $37,%10100000 + !byte $37,%10000000 + !byte $37,%01100000 + !byte $37,%01000000 + !byte $37,%00100000 + !byte $37,%00000000 + !byte $01,%00101001 + !byte $03,%00101001 + !byte $05,%00101001 + !byte $07,%00101001 + !byte $09,%00101001 + !byte $0B,%00001001 + !byte $0D,%00001001 + !byte $0F,%11001000 + !byte $11,%10101000 + !byte $13,%10101000 + !byte $13,%10001000 + !byte $15,%10001000 + !byte $17,%01101000 + !byte $19,%01001000 + !byte $19,%00101000 + !byte $1B,%00001000 + !byte $1D,%11000111 + !byte $1F,%10100111 + !byte $1F,%10000111 + !byte $21,%01100111 + !byte $23,%00100111 + !byte $25,%11000110 + !byte $27,%10000110 + !byte $29,%01000110 + !byte $29,%00100110 + !byte $2B,%11000101 + !byte $2D,%10000101 + !byte $2D,%01100101 + !byte $2F,%00000101 + !byte $2F,%11000100 + !byte $31,%10000100 + !byte $31,%01100100 + !byte $33,%11000011 + !byte $33,%10100011 + !byte $35,%00100011 + !byte $35,%00000011 + !byte $35,%11000010 + !byte $37,%00100010 + !byte $37,%00000010 + !byte $37,%11000001 + !byte $37,%10100001 + !byte $37,%10000001 + !byte $01,%01001001 + !byte $03,%01001001 + !byte $05,%01001001 + !byte $07,%01001001 + !byte $09,%01001001 + !byte $0B,%00101001 + !byte $0D,%00101001 + !byte $0F,%00001001 + !byte $11,%11001000 + !byte $13,%11001000 + !byte $15,%10101000 + !byte $17,%10001000 + !byte $19,%01101000 + !byte $1B,%00101000 + !byte $1D,%00001000 + !byte $1F,%11000111 + !byte $21,%10000111 + !byte $23,%01000111 + !byte $25,%00100111 + !byte $25,%00000111 + !byte $27,%11000110 + !byte $27,%10100110 + !byte $29,%01100110 + !byte $2B,%00100110 + !byte $2B,%00000110 + !byte $2D,%10100101 + !byte $2F,%01000101 + !byte $2F,%00100101 + !byte $31,%11000100 + !byte $31,%10100100 + !byte $33,%00100100 + !byte $33,%00000100 + !byte $35,%10000011 + !byte $35,%01100011 + !byte $35,%01000011 + !byte $37,%10000010 + !byte $37,%01100010 + !byte $37,%01000010 + !byte $39,%00100001 + !byte $39,%00000001 + !byte $39,%11000000 + !byte $39,%10100000 + !byte $39,%10000000 + !byte $39,%01100000 + !byte $39,%01000000 + !byte $39,%00100000 + !byte $39,%00000000 + !byte $01,%01101001 + !byte $03,%01101001 + !byte $05,%01101001 + !byte $07,%01101001 + !byte $09,%01101001 + !byte $0B,%01001001 + !byte $0D,%01001001 + !byte $0F,%00101001 + !byte $11,%00001001 + !byte $13,%00001001 + !byte $15,%11001000 + !byte $17,%10101000 + !byte $19,%10001000 + !byte $1B,%01101000 + !byte $1B,%01001000 + !byte $1D,%00101000 + !byte $1F,%00001000 + !byte $21,%11000111 + !byte $21,%10100111 + !byte $23,%10000111 + !byte $23,%01100111 + !byte $25,%01000111 + !byte $27,%00000111 + !byte $29,%10100110 + !byte $29,%10000110 + !byte $2B,%01000110 + !byte $2D,%00000110 + !byte $2D,%11000101 + !byte $2F,%10000101 + !byte $2F,%01100101 + !byte $31,%00000101 + !byte $33,%10000100 + !byte $33,%01100100 + !byte $33,%01000100 + !byte $35,%11000011 + !byte $35,%10100011 + !byte $37,%00000011 + !byte $37,%11000010 + !byte $37,%10100010 + !byte $39,%00000010 + !byte $39,%11000001 + !byte $39,%10100001 + !byte $39,%10000001 + !byte $39,%01100001 + !byte $39,%01000001 + !byte $01,%10001001 + !byte $03,%10001001 + !byte $05,%10001001 + !byte $07,%10001001 + !byte $09,%10001001 + !byte $0B,%01101001 + !byte $0D,%01101001 + !byte $0F,%01001001 + !byte $11,%00101001 + !byte $13,%00101001 + !byte $15,%00001001 + !byte $17,%11001000 + !byte $19,%10101000 + !byte $1B,%10001000 + !byte $1D,%01101000 + !byte $1D,%01001000 + !byte $1F,%00101000 + !byte $21,%00001000 + !byte $23,%10100111 + !byte $25,%01100111 + !byte $27,%00100111 + !byte $29,%11000110 + !byte $2B,%10000110 + !byte $2B,%01100110 + !byte $2D,%00100110 + !byte $2F,%10100101 + !byte $31,%01000101 + !byte $31,%00100101 + !byte $33,%11000100 + !byte $33,%10100100 + !byte $35,%00100100 + !byte $35,%00000100 + !byte $37,%01100011 + !byte $37,%01000011 + !byte $37,%00100011 + !byte $39,%01100010 + !byte $39,%01000010 + !byte $39,%00100010 + !byte $3B,%11000000 + !byte $3B,%10100000 + !byte $3B,%10000000 + !byte $3B,%01100000 + !byte $3B,%01000000 + !byte $3B,%00100000 + !byte $3B,%00000000 + !byte $01,%10101001 + !byte $03,%10101001 + !byte $05,%10101001 + !byte $07,%10101001 + !byte $09,%10101001 + !byte $0B,%10001001 + !byte $0D,%10001001 + !byte $0F,%01101001 + !byte $11,%01101001 + !byte $11,%01001001 + !byte $13,%01001001 + !byte $15,%00101001 + !byte $17,%00001001 + !byte $19,%11001000 + !byte $1B,%10101000 + !byte $1D,%10001000 + !byte $1F,%01001000 + !byte $21,%00101000 + !byte $23,%11000111 + !byte $25,%10100111 + !byte $25,%10000111 + !byte $27,%01100111 + !byte $27,%01000111 + !byte $29,%00100111 + !byte $29,%00000111 + !byte $2B,%10100110 + !byte $2D,%01100110 + !byte $2D,%01000110 + !byte $2F,%00000110 + !byte $2F,%11000101 + !byte $31,%10000101 + !byte $31,%01100101 + !byte $33,%00100101 + !byte $33,%00000101 + !byte $35,%01100100 + !byte $35,%01000100 + !byte $37,%11000011 + !byte $37,%10100011 + !byte $37,%10000011 + !byte $39,%00000011 + !byte $39,%11000010 + !byte $39,%10100010 + !byte $39,%10000010 + !byte $3B,%10100001 + !byte $3B,%10000001 + !byte $3B,%01100001 + !byte $3B,%01000001 + !byte $3B,%00100001 + !byte $3B,%00000001 + !byte $01,%11001001 + !byte $03,%11001001 + !byte $05,%11001001 + !byte $07,%11001001 + !byte $09,%11001001 + !byte $0B,%10101001 + !byte $0D,%10101001 + !byte $0F,%10001001 + !byte $11,%10001001 + !byte $13,%01101001 + !byte $15,%01001001 + !byte $17,%00101001 + !byte $19,%00001001 + !byte $1B,%11001000 + !byte $1D,%10101000 + !byte $1F,%10001000 + !byte $1F,%01101000 + !byte $21,%01001000 + !byte $23,%00101000 + !byte $23,%00001000 + !byte $25,%11000111 + !byte $27,%10000111 + !byte $29,%01000111 + !byte $2B,%00000111 + !byte $2B,%11000110 + !byte $2D,%10000110 + !byte $2F,%01000110 + !byte $2F,%00100110 + !byte $31,%11000101 + !byte $31,%10100101 + !byte $33,%01000101 + !byte $35,%11000100 + !byte $35,%10100100 + !byte $35,%10000100 + !byte $37,%00100100 + !byte $37,%00000100 + !byte $39,%01100011 + !byte $39,%01000011 + !byte $39,%00100011 + !byte $3B,%01100010 + !byte $3B,%01000010 + !byte $3B,%00100010 + !byte $3B,%00000010 + !byte $3B,%11000001 + !byte $3D,%01000000 + !byte $3D,%00100000 + !byte $3D,%00000000 + !byte $01,%00001010 + !byte $03,%00001010 + !byte $05,%00001010 + !byte $07,%00001010 + !byte $09,%00001010 + !byte $0B,%11001001 + !byte $0D,%11001001 + !byte $0F,%10101001 + !byte $11,%10101001 + !byte $13,%10001001 + !byte $15,%01101001 + !byte $17,%01001001 + !byte $19,%00101001 + !byte $1B,%00001001 + !byte $1D,%11001000 + !byte $1F,%10101000 + !byte $21,%01101000 + !byte $23,%01001000 + !byte $25,%00001000 + !byte $27,%10100111 + !byte $29,%01100111 + !byte $2B,%00100111 + !byte $2D,%11000110 + !byte $2D,%10100110 + !byte $2F,%01100110 + !byte $31,%00000110 + !byte $33,%10000101 + !byte $33,%01100101 + !byte $35,%00100101 + !byte $35,%00000101 + !byte $37,%10000100 + !byte $37,%01100100 + !byte $37,%01000100 + !byte $39,%11000011 + !byte $39,%10100011 + !byte $39,%10000011 + !byte $3B,%00000011 + !byte $3B,%11000010 + !byte $3B,%10100010 + !byte $3B,%10000010 + !byte $3D,%10000001 + !byte $3D,%01100001 + !byte $3D,%01000001 + !byte $3D,%00100001 + !byte $3D,%00000001 + !byte $3D,%11000000 + !byte $3D,%10100000 + !byte $3D,%10000000 + !byte $3D,%01100000 + !byte $01,%00101010 + !byte $03,%00101010 + !byte $05,%00101010 + !byte $07,%00101010 + !byte $09,%00101010 + !byte $0B,%00001010 + !byte $0D,%00001010 + !byte $0F,%11001001 + !byte $11,%11001001 + !byte $13,%10101001 + !byte $15,%10001001 + !byte $17,%01101001 + !byte $19,%01001001 + !byte $1B,%00101001 + !byte $1D,%00001001 + !byte $1F,%11001000 + !byte $21,%10001000 + !byte $23,%01101000 + !byte $25,%00101000 + !byte $27,%00001000 + !byte $27,%11000111 + !byte $29,%10100111 + !byte $29,%10000111 + !byte $2B,%01100111 + !byte $2B,%01000111 + !byte $2D,%00000111 + !byte $2F,%10100110 + !byte $2F,%10000110 + !byte $31,%01000110 + !byte $31,%00100110 + !byte $33,%11000101 + !byte $33,%10100101 + !byte $35,%01100101 + !byte $35,%01000101 + !byte $37,%11000100 + !byte $37,%10100100 + !byte $39,%00100100 + !byte $39,%00000100 + !byte $3B,%01100011 + !byte $3B,%01000011 + !byte $3B,%00100011 + !byte $3D,%01000010 + !byte $3D,%00100010 + !byte $3D,%00000010 + !byte $3D,%11000001 + !byte $3D,%10100001 + !byte $01,%01001010 + !byte $03,%01001010 + !byte $05,%01001010 + !byte $07,%01001010 + !byte $09,%01001010 + !byte $0B,%00101010 + !byte $0D,%00101010 + !byte $0F,%00001010 + !byte $11,%00001010 + !byte $13,%11001001 + !byte $15,%10101001 + !byte $17,%10001001 + !byte $19,%01101001 + !byte $1B,%01001001 + !byte $1D,%00101001 + !byte $1F,%00001001 + !byte $21,%11001000 + !byte $21,%10101000 + !byte $23,%10001000 + !byte $25,%01101000 + !byte $25,%01001000 + !byte $27,%00101000 + !byte $29,%11000111 + !byte $2B,%10000111 + !byte $2D,%01000111 + !byte $2D,%00100111 + !byte $2F,%11000110 + !byte $31,%10000110 + !byte $31,%01100110 + !byte $33,%00100110 + !byte $33,%00000110 + !byte $35,%10100101 + !byte $35,%10000101 + !byte $37,%00100101 + !byte $37,%00000101 + !byte $39,%01100100 + !byte $39,%01000100 + !byte $3B,%10100011 + !byte $3B,%10000011 + !byte $3D,%11000010 + !byte $3D,%10100010 + !byte $3D,%10000010 + !byte $3D,%01100010 + !byte $3F,%01000001 + !byte $3F,%00100001 + !byte $3F,%00000001 + !byte $3F,%11000000 + !byte $3F,%10100000 + !byte $3F,%10000000 + !byte $3F,%01100000 + !byte $3F,%01000000 + !byte $3F,%00100000 + !byte $3F,%00000000 + !byte $01,%01101010 + !byte $03,%01101010 + !byte $05,%01101010 + !byte $07,%01101010 + !byte $09,%01101010 + !byte $0B,%01001010 + !byte $0D,%01001010 + !byte $0F,%00101010 + !byte $11,%00101010 + !byte $13,%00001010 + !byte $15,%11001001 + !byte $17,%10101001 + !byte $19,%10001001 + !byte $1B,%01101001 + !byte $1D,%01001001 + !byte $1F,%00101001 + !byte $21,%00001001 + !byte $23,%10101000 + !byte $25,%10001000 + !byte $27,%01001000 + !byte $29,%00001000 + !byte $2B,%10100111 + !byte $2D,%01100111 + !byte $2F,%00100111 + !byte $2F,%00000111 + !byte $31,%10100110 + !byte $33,%01000110 + !byte $35,%11000101 + !byte $37,%01100101 + !byte $37,%01000101 + !byte $39,%11000100 + !byte $39,%10100100 + !byte $39,%10000100 + !byte $3B,%00100100 + !byte $3B,%00000100 + !byte $3B,%11000011 + !byte $3D,%01000011 + !byte $3D,%00100011 + !byte $3D,%00000011 + !byte $3F,%00100010 + !byte $3F,%00000010 + !byte $3F,%11000001 + !byte $3F,%10100001 + !byte $3F,%10000001 + !byte $3F,%01100001 + !byte $01,%10001010 + !byte $03,%10001010 + !byte $05,%10001010 + !byte $07,%10001010 + !byte $09,%10001010 + !byte $0B,%01101010 + !byte $0D,%01101010 + !byte $0F,%01001010 + !byte $11,%01001010 + !byte $13,%00101010 + !byte $15,%00001010 + !byte $17,%11001001 + !byte $19,%11001001 + !byte $19,%10101001 + !byte $1B,%10101001 + !byte $1B,%10001001 + !byte $1D,%01101001 + !byte $1F,%01001001 + !byte $21,%00101001 + !byte $23,%00001001 + !byte $23,%11001000 + !byte $25,%10101000 + !byte $27,%01101000 + !byte $29,%01001000 + !byte $29,%00101000 + !byte $2B,%00001000 + !byte $2B,%11000111 + !byte $2D,%10000111 + !byte $2F,%01000111 + !byte $31,%00000111 + !byte $31,%11000110 + !byte $33,%10000110 + !byte $33,%01100110 + !byte $35,%00100110 + !byte $35,%00000110 + !byte $37,%10100101 + !byte $37,%10000101 + !byte $39,%00100101 + !byte $39,%00000101 + !byte $3B,%01100100 + !byte $3B,%01000100 + !byte $3D,%10100011 + !byte $3D,%10000011 + !byte $3D,%01100011 + !byte $3F,%10100010 + !byte $3F,%10000010 + !byte $3F,%01100010 + !byte $3F,%01000010 + !byte $41,%00000001 + !byte $41,%11000000 + !byte $41,%10100000 + !byte $41,%10000000 + !byte $41,%01100000 + !byte $41,%01000000 + !byte $41,%00100000 + !byte $41,%00000000 + !byte $01,%10101010 + !byte $03,%10101010 + !byte $05,%10101010 + !byte $07,%10101010 + !byte $09,%10101010 + !byte $0B,%10001010 + !byte $0D,%10001010 + !byte $0F,%01101010 + !byte $11,%01101010 + !byte $13,%01001010 + !byte $15,%00101010 + !byte $17,%00101010 + !byte $17,%00001010 + !byte $19,%00001010 + !byte $1B,%11001001 + !byte $1D,%10101001 + !byte $1D,%10001001 + !byte $1F,%01101001 + !byte $21,%01001001 + !byte $23,%00101001 + !byte $25,%11001000 + !byte $27,%10101000 + !byte $27,%10001000 + !byte $29,%01101000 + !byte $2B,%00101000 + !byte $2D,%11000111 + !byte $2D,%10100111 + !byte $2F,%10000111 + !byte $2F,%01100111 + !byte $31,%00100111 + !byte $33,%11000110 + !byte $33,%10100110 + !byte $35,%01100110 + !byte $35,%01000110 + !byte $37,%11000101 + !byte $39,%01100101 + !byte $39,%01000101 + !byte $3B,%10100100 + !byte $3B,%10000100 + !byte $3D,%00100100 + !byte $3D,%00000100 + !byte $3D,%11000011 + !byte $3F,%00100011 + !byte $3F,%00000011 + !byte $3F,%11000010 + !byte $41,%00000010 + !byte $41,%11000001 + !byte $41,%10100001 + !byte $41,%10000001 + !byte $41,%01100001 + !byte $41,%01000001 + !byte $41,%00100001 + !byte $01,%11001010 + !byte $03,%11001010 + !byte $05,%11001010 + !byte $07,%11001010 + !byte $09,%11001010 + !byte $0B,%10101010 + !byte $0D,%10101010 + !byte $0F,%10001010 + !byte $11,%10001010 + !byte $13,%01101010 + !byte $15,%01001010 + !byte $17,%01001010 + !byte $19,%00101010 + !byte $1B,%00001010 + !byte $1D,%11001001 + !byte $1F,%10101001 + !byte $1F,%10001001 + !byte $21,%01101001 + !byte $23,%01001001 + !byte $25,%00001001 + !byte $27,%11001000 + !byte $29,%10001000 + !byte $2B,%01001000 + !byte $2D,%00001000 + !byte $2F,%10100111 + !byte $31,%01100111 + !byte $31,%01000111 + !byte $33,%00000111 + !byte $35,%10000110 + !byte $37,%00100110 + !byte $37,%00000110 + !byte $39,%10100101 + !byte $39,%10000101 + !byte $3B,%00100101 + !byte $3B,%00000101 + !byte $3B,%11000100 + !byte $3D,%01100100 + !byte $3D,%01000100 + !byte $3F,%10000011 + !byte $3F,%01100011 + !byte $3F,%01000011 + !byte $41,%10000010 + !byte $41,%01100010 + !byte $41,%01000010 + !byte $41,%00100010 + !byte $43,%10000000 + !byte $43,%01100000 + !byte $43,%01000000 + !byte $43,%00100000 + !byte $43,%00000000 + !byte $01,%00001011 + !byte $03,%00001011 + !byte $05,%00001011 + !byte $07,%00001011 + !byte $09,%00001011 + !byte $0B,%11001010 + !byte $0D,%11001010 + !byte $0F,%10101010 + !byte $11,%10101010 + !byte $13,%10001010 + !byte $15,%10001010 + !byte $15,%01101010 + !byte $17,%01101010 + !byte $19,%01001010 + !byte $1B,%00101010 + !byte $1D,%00001010 + !byte $1F,%11001001 + !byte $21,%10001001 + !byte $23,%01101001 + !byte $25,%01001001 + !byte $25,%00101001 + !byte $27,%00001001 + !byte $29,%10101000 + !byte $2B,%10001000 + !byte $2B,%01101000 + !byte $2D,%01001000 + !byte $2D,%00101000 + !byte $2F,%11000111 + !byte $31,%10000111 + !byte $33,%01000111 + !byte $33,%00100111 + !byte $35,%11000110 + !byte $35,%10100110 + !byte $37,%01100110 + !byte $37,%01000110 + !byte $39,%11000101 + !byte $3B,%01100101 + !byte $3B,%01000101 + !byte $3D,%10100100 + !byte $3D,%10000100 + !byte $3F,%00000100 + !byte $3F,%11000011 + !byte $3F,%10100011 + !byte $41,%00100011 + !byte $41,%00000011 + !byte $41,%11000010 + !byte $41,%10100010 + !byte $43,%10100001 + !byte $43,%10000001 + !byte $43,%01100001 + !byte $43,%01000001 + !byte $43,%00100001 + !byte $43,%00000001 + !byte $43,%11000000 + !byte $43,%10100000 + !byte $01,%00101011 + !byte $03,%00101011 + !byte $05,%00101011 + !byte $07,%00101011 + !byte $09,%00101011 + !byte $0B,%00001011 + !byte $0D,%00001011 + !byte $0F,%11001010 + !byte $11,%11001010 + !byte $13,%10101010 + !byte $15,%10101010 + !byte $17,%10001010 + !byte $19,%01101010 + !byte $1B,%01001010 + !byte $1D,%00101010 + !byte $1F,%00001010 + !byte $21,%11001001 + !byte $21,%10101001 + !byte $23,%10001001 + !byte $25,%01101001 + !byte $27,%00101001 + !byte $29,%00001001 + !byte $29,%11001000 + !byte $2B,%10101000 + !byte $2D,%01101000 + !byte $2F,%00101000 + !byte $2F,%00001000 + !byte $31,%11000111 + !byte $31,%10100111 + !byte $33,%01100111 + !byte $35,%00100111 + !byte $35,%00000111 + !byte $37,%10100110 + !byte $37,%10000110 + !byte $39,%00100110 + !byte $39,%00000110 + !byte $3B,%10100101 + !byte $3B,%10000101 + !byte $3D,%00100101 + !byte $3D,%00000101 + !byte $3D,%11000100 + !byte $3F,%01100100 + !byte $3F,%01000100 + !byte $3F,%00100100 + !byte $41,%10000011 + !byte $41,%01100011 + !byte $41,%01000011 + !byte $43,%01100010 + !byte $43,%01000010 + !byte $43,%00100010 + !byte $43,%00000010 + !byte $43,%11000001 + !byte $01,%01001011 + !byte $03,%01001011 + !byte $05,%01001011 + !byte $07,%01001011 + !byte $09,%01001011 + !byte $0B,%00101011 + !byte $0D,%00101011 + !byte $0F,%00101011 + !byte $0F,%00001011 + !byte $11,%00001011 + !byte $13,%11001010 + !byte $15,%11001010 + !byte $17,%10101010 + !byte $19,%10001010 + !byte $1B,%01101010 + !byte $1D,%01001010 + !byte $1F,%00101010 + !byte $21,%00001010 + !byte $23,%10101001 + !byte $25,%10001001 + !byte $27,%01101001 + !byte $27,%01001001 + !byte $29,%00101001 + !byte $2B,%11001000 + !byte $2D,%10001000 + !byte $2F,%01001000 + !byte $31,%00001000 + !byte $33,%10100111 + !byte $33,%10000111 + !byte $35,%01000111 + !byte $37,%11000110 + !byte $39,%01100110 + !byte $39,%01000110 + !byte $3B,%00000110 + !byte $3B,%11000101 + !byte $3D,%01100101 + !byte $3D,%01000101 + !byte $3F,%10100100 + !byte $3F,%10000100 + !byte $41,%00000100 + !byte $41,%11000011 + !byte $41,%10100011 + !byte $43,%00000011 + !byte $43,%11000010 + !byte $43,%10100010 + !byte $43,%10000010 + !byte $45,%01100001 + !byte $45,%01000001 + !byte $45,%00100001 + !byte $45,%00000001 + !byte $45,%11000000 + !byte $45,%10100000 + !byte $45,%10000000 + !byte $45,%01100000 + !byte $45,%01000000 + !byte $45,%00100000 + !byte $45,%00000000 + !byte $01,%01101011 + !byte $03,%01101011 + !byte $05,%01101011 + !byte $07,%01101011 + !byte $09,%01101011 + !byte $0B,%01001011 + !byte $0D,%01001011 + !byte $0F,%01001011 + !byte $11,%00101011 + !byte $13,%00001011 + !byte $15,%00001011 + !byte $17,%11001010 + !byte $19,%10101010 + !byte $1B,%10001010 + !byte $1D,%01101010 + !byte $1F,%01001010 + !byte $21,%00101010 + !byte $23,%00001010 + !byte $23,%11001001 + !byte $25,%10101001 + !byte $27,%10001001 + !byte $29,%01001001 + !byte $2B,%00001001 + !byte $2D,%10101000 + !byte $2F,%10001000 + !byte $2F,%01101000 + !byte $31,%00101000 + !byte $33,%11000111 + !byte $35,%10000111 + !byte $35,%01100111 + !byte $37,%00100111 + !byte $37,%00000111 + !byte $39,%10100110 + !byte $39,%10000110 + !byte $3B,%00100110 + !byte $3D,%10100101 + !byte $3D,%10000101 + !byte $3F,%00100101 + !byte $3F,%00000101 + !byte $3F,%11000100 + !byte $41,%01100100 + !byte $41,%01000100 + !byte $41,%00100100 + !byte $43,%10000011 + !byte $43,%01100011 + !byte $43,%01000011 + !byte $43,%00100011 + !byte $45,%01000010 + !byte $45,%00100010 + !byte $45,%00000010 + !byte $45,%11000001 + !byte $45,%10100001 + !byte $45,%10000001 + !byte $01,%10001011 + !byte $03,%10001011 + !byte $05,%10001011 + !byte $07,%10001011 + !byte $09,%10001011 + !byte $0B,%01101011 + !byte $0D,%01101011 + !byte $0F,%01101011 + !byte $11,%01001011 + !byte $13,%00101011 + !byte $15,%00101011 + !byte $17,%00001011 + !byte $19,%11001010 + !byte $1B,%10101010 + !byte $1D,%10001010 + !byte $1F,%01101010 + !byte $21,%01001010 + !byte $23,%00101010 + !byte $25,%11001001 + !byte $27,%10101001 + !byte $29,%01101001 + !byte $2B,%01001001 + !byte $2B,%00101001 + !byte $2D,%00001001 + !byte $2D,%11001000 + !byte $2F,%10101000 + !byte $31,%01101000 + !byte $31,%01001000 + !byte $33,%00101000 + !byte $33,%00001000 + !byte $35,%10100111 + !byte $37,%01000111 + !byte $39,%11000110 + !byte $3B,%01100110 + !byte $3B,%01000110 + !byte $3D,%00000110 + !byte $3D,%11000101 + !byte $3F,%01100101 + !byte $3F,%01000101 + !byte $41,%10100100 + !byte $41,%10000100 + !byte $43,%11000011 + !byte $43,%10100011 + !byte $45,%11000010 + !byte $45,%10100010 + !byte $45,%10000010 + !byte $45,%01100010 + !byte $47,%00100001 + !byte $47,%00000001 + !byte $47,%11000000 + !byte $47,%10100000 + !byte $47,%10000000 + !byte $47,%01100000 + !byte $47,%01000000 + !byte $47,%00100000 + !byte $47,%00000000 + !byte $01,%10101011 + !byte $03,%10101011 + !byte $05,%10101011 + !byte $07,%10101011 + !byte $09,%10101011 + !byte $0B,%10001011 + !byte $0D,%10001011 + !byte $0F,%10001011 + !byte $11,%01101011 + !byte $13,%01001011 + !byte $15,%01001011 + !byte $17,%00101011 + !byte $19,%00001011 + !byte $1B,%11001010 + !byte $1D,%10101010 + !byte $1F,%10001010 + !byte $21,%01101010 + !byte $23,%01001010 + !byte $25,%00101010 + !byte $25,%00001010 + !byte $27,%11001001 + !byte $29,%10101001 + !byte $29,%10001001 + !byte $2B,%01101001 + !byte $2D,%00101001 + !byte $2F,%11001000 + !byte $31,%10001000 + !byte $33,%01001000 + !byte $35,%00001000 + !byte $35,%11000111 + !byte $37,%10000111 + !byte $37,%01100111 + !byte $39,%00100111 + !byte $39,%00000111 + !byte $3B,%10100110 + !byte $3B,%10000110 + !byte $3D,%01000110 + !byte $3D,%00100110 + !byte $3F,%10100101 + !byte $3F,%10000101 + !byte $41,%00000101 + !byte $41,%11000100 + !byte $43,%01000100 + !byte $43,%00100100 + !byte $43,%00000100 + !byte $45,%01100011 + !byte $45,%01000011 + !byte $45,%00100011 + !byte $45,%00000011 + !byte $47,%00100010 + !byte $47,%00000010 + !byte $47,%11000001 + !byte $47,%10100001 + !byte $47,%10000001 + !byte $47,%01100001 + !byte $47,%01000001 + !byte $01,%11001011 + !byte $03,%11001011 + !byte $05,%11001011 + !byte $07,%11001011 + !byte $09,%11001011 + !byte $0B,%10101011 + !byte $0D,%10101011 + !byte $0F,%10101011 + !byte $11,%10001011 + !byte $13,%01101011 + !byte $15,%01101011 + !byte $17,%01001011 + !byte $19,%00101011 + !byte $1B,%00001011 + !byte $1D,%11001010 + !byte $1F,%10101010 + !byte $21,%10001010 + !byte $23,%01101010 + !byte $25,%01001010 + !byte $27,%00001010 + !byte $29,%11001001 + !byte $2B,%10001001 + !byte $2D,%01001001 + !byte $2F,%00001001 + !byte $31,%11001000 + !byte $31,%10101000 + !byte $33,%01101000 + !byte $35,%00101000 + !byte $37,%10100111 + !byte $39,%01100111 + !byte $39,%01000111 + !byte $3B,%00000111 + !byte $3B,%11000110 + !byte $3D,%01100110 + !byte $3F,%00000110 + !byte $3F,%11000101 + !byte $41,%01100101 + !byte $41,%01000101 + !byte $41,%00100101 + !byte $43,%10100100 + !byte $43,%10000100 + !byte $43,%01100100 + !byte $45,%11000011 + !byte $45,%10100011 + !byte $45,%10000011 + !byte $47,%10100010 + !byte $47,%10000010 + !byte $47,%01100010 + !byte $47,%01000010 + !byte $49,%10100000 + !byte $49,%10000000 + !byte $49,%01100000 + !byte $49,%01000000 + !byte $49,%00100000 + !byte $49,%00000000 + !byte $01,%00001100 + !byte $03,%00001100 + !byte $05,%00001100 + !byte $07,%00001100 + !byte $09,%00001100 + !byte $0B,%11001011 + !byte $0D,%11001011 + !byte $0F,%11001011 + !byte $11,%10101011 + !byte $13,%10101011 + !byte $13,%10001011 + !byte $15,%10001011 + !byte $17,%01101011 + !byte $19,%01001011 + !byte $1B,%00101011 + !byte $1D,%00001011 + !byte $1F,%11001010 + !byte $21,%10101010 + !byte $23,%10001010 + !byte $25,%01101010 + !byte $27,%01001010 + !byte $27,%00101010 + !byte $29,%00001010 + !byte $2B,%10101001 + !byte $2D,%10001001 + !byte $2D,%01101001 + !byte $2F,%01001001 + !byte $2F,%00101001 + !byte $31,%00001001 + !byte $33,%10101000 + !byte $33,%10001000 + !byte $35,%01101000 + !byte $35,%01001000 + !byte $37,%00001000 + !byte $37,%11000111 + !byte $39,%10000111 + !byte $3B,%00100111 + !byte $3D,%10100110 + !byte $3D,%10000110 + !byte $3F,%01000110 + !byte $3F,%00100110 + !byte $41,%10100101 + !byte $41,%10000101 + !byte $43,%00000101 + !byte $43,%11000100 + !byte $45,%01000100 + !byte $45,%00100100 + !byte $45,%00000100 + !byte $47,%01000011 + !byte $47,%00100011 + !byte $47,%00000011 + !byte $47,%11000010 + !byte $49,%11000001 + !byte $49,%10100001 + !byte $49,%10000001 + !byte $49,%01100001 + !byte $49,%01000001 + !byte $49,%00100001 + !byte $49,%00000001 + !byte $49,%11000000 + !byte $01,%00101100 + !byte $03,%00101100 + !byte $05,%00101100 + !byte $07,%00101100 + !byte $09,%00101100 + !byte $0B,%00001100 + !byte $0D,%00001100 + !byte $0F,%00001100 + !byte $11,%11001011 + !byte $13,%11001011 + !byte $15,%10101011 + !byte $17,%10001011 + !byte $19,%01101011 + !byte $1B,%01101011 + !byte $1B,%01001011 + !byte $1D,%01001011 + !byte $1D,%00101011 + !byte $1F,%00101011 + !byte $1F,%00001011 + !byte $21,%11001010 + !byte $23,%10101010 + !byte $25,%10001010 + !byte $27,%01101010 + !byte $29,%00101010 + !byte $2B,%00001010 + !byte $2B,%11001001 + !byte $2D,%10101001 + !byte $2F,%01101001 + !byte $31,%00101001 + !byte $33,%11001000 + !byte $35,%10001000 + !byte $37,%01001000 + !byte $37,%00101000 + !byte $39,%11000111 + !byte $39,%10100111 + !byte $3B,%01100111 + !byte $3B,%01000111 + !byte $3D,%00000111 + !byte $3D,%11000110 + !byte $3F,%10000110 + !byte $3F,%01100110 + !byte $41,%00000110 + !byte $41,%11000101 + !byte $43,%01000101 + !byte $43,%00100101 + !byte $45,%10100100 + !byte $45,%10000100 + !byte $45,%01100100 + !byte $47,%10100011 + !byte $47,%10000011 + !byte $47,%01100011 + !byte $49,%10100010 + !byte $49,%10000010 + !byte $49,%01100010 + !byte $49,%01000010 + !byte $49,%00100010 + !byte $49,%00000010 + !byte $01,%01001100 + !byte $03,%01001100 + !byte $05,%01001100 + !byte $07,%01001100 + !byte $09,%01001100 + !byte $0B,%01001100 + !byte $0B,%00101100 + !byte $0D,%00101100 + !byte $0F,%00101100 + !byte $11,%00001100 + !byte $13,%00001100 + !byte $15,%11001011 + !byte $17,%10101011 + !byte $19,%10001011 + !byte $1B,%10001011 + !byte $1D,%01101011 + !byte $1F,%01001011 + !byte $21,%00101011 + !byte $21,%00001011 + !byte $23,%11001010 + !byte $25,%10101010 + !byte $27,%10001010 + !byte $29,%01001010 + !byte $2B,%00101010 + !byte $2D,%11001001 + !byte $2F,%10001001 + !byte $31,%01101001 + !byte $31,%01001001 + !byte $33,%00001001 + !byte $35,%10101000 + !byte $37,%01101000 + !byte $39,%00001000 + !byte $3B,%10100111 + !byte $3B,%10000111 + !byte $3D,%01000111 + !byte $3D,%00100111 + !byte $3F,%10100110 + !byte $41,%01000110 + !byte $41,%00100110 + !byte $43,%10100101 + !byte $43,%10000101 + !byte $43,%01100101 + !byte $45,%00000101 + !byte $45,%11000100 + !byte $47,%00100100 + !byte $47,%00000100 + !byte $47,%11000011 + !byte $49,%00100011 + !byte $49,%00000011 + !byte $49,%11000010 + !byte $4B,%10100001 + !byte $4B,%10000001 + !byte $4B,%01100001 + !byte $4B,%01000001 + !byte $4B,%00100001 + !byte $4B,%00000001 + !byte $4B,%11000000 + !byte $4B,%10100000 + !byte $4B,%10000000 + !byte $4B,%01100000 + !byte $4B,%01000000 + !byte $4B,%00100000 + !byte $4B,%00000000 + !byte $01,%01101100 + !byte $03,%01101100 + !byte $05,%01101100 + !byte $07,%01101100 + !byte $09,%01101100 + !byte $0B,%01101100 + !byte $0D,%01001100 + !byte $0F,%01001100 + !byte $11,%00101100 + !byte $13,%00101100 + !byte $15,%00001100 + !byte $17,%11001011 + !byte $19,%11001011 + !byte $19,%10101011 + !byte $1B,%10101011 + !byte $1D,%10001011 + !byte $1F,%01101011 + !byte $21,%01001011 + !byte $23,%00101011 + !byte $23,%00001011 + !byte $25,%11001010 + !byte $27,%10101010 + !byte $29,%10001010 + !byte $29,%01101010 + !byte $2B,%01001010 + !byte $2D,%00001010 + !byte $2F,%11001001 + !byte $2F,%10101001 + !byte $31,%10001001 + !byte $33,%01001001 + !byte $33,%00101001 + !byte $35,%00001001 + !byte $35,%11001000 + !byte $37,%10001000 + !byte $39,%01001000 + !byte $39,%00101000 + !byte $3B,%11000111 + !byte $3D,%01100111 + !byte $3F,%00000111 + !byte $3F,%11000110 + !byte $41,%10000110 + !byte $41,%01100110 + !byte $43,%00000110 + !byte $43,%11000101 + !byte $45,%01000101 + !byte $45,%00100101 + !byte $47,%10000100 + !byte $47,%01100100 + !byte $47,%01000100 + !byte $49,%10100011 + !byte $49,%10000011 + !byte $49,%01100011 + !byte $49,%01000011 + !byte $4B,%01100010 + !byte $4B,%01000010 + !byte $4B,%00100010 + !byte $4B,%00000010 + !byte $4B,%11000001 + !byte $01,%10001100 + !byte $03,%10001100 + !byte $05,%10001100 + !byte $07,%10001100 + !byte $09,%10001100 + !byte $0B,%10001100 + !byte $0D,%01101100 + !byte $0F,%01101100 + !byte $11,%01001100 + !byte $13,%01001100 + !byte $15,%00101100 + !byte $17,%00001100 + !byte $19,%00001100 + !byte $1B,%11001011 + !byte $1D,%10101011 + !byte $1F,%10001011 + !byte $21,%01101011 + !byte $23,%01001011 + !byte $25,%00001011 + !byte $27,%11001010 + !byte $29,%10101010 + !byte $2B,%01101010 + !byte $2D,%01001010 + !byte $2D,%00101010 + !byte $2F,%00001010 + !byte $31,%10101001 + !byte $33,%01101001 + !byte $35,%00101001 + !byte $37,%11001000 + !byte $37,%10101000 + !byte $39,%10001000 + !byte $39,%01101000 + !byte $3B,%00101000 + !byte $3B,%00001000 + !byte $3D,%10100111 + !byte $3D,%10000111 + !byte $3F,%01000111 + !byte $3F,%00100111 + !byte $41,%11000110 + !byte $41,%10100110 + !byte $43,%01000110 + !byte $43,%00100110 + !byte $45,%10100101 + !byte $45,%10000101 + !byte $45,%01100101 + !byte $47,%00000101 + !byte $47,%11000100 + !byte $47,%10100100 + !byte $49,%00100100 + !byte $49,%00000100 + !byte $49,%11000011 + !byte $4B,%00100011 + !byte $4B,%00000011 + !byte $4B,%11000010 + !byte $4B,%10100010 + !byte $4B,%10000010 + !byte $4D,%01100001 + !byte $4D,%01000001 + !byte $4D,%00100001 + !byte $4D,%00000001 + !byte $4D,%11000000 + !byte $4D,%10100000 + !byte $4D,%10000000 + !byte $4D,%01100000 + !byte $4D,%01000000 + !byte $4D,%00100000 + !byte $4D,%00000000 + !byte $01,%10101100 + !byte $03,%10101100 + !byte $05,%10101100 + !byte $07,%10101100 + !byte $09,%10101100 + !byte $0B,%10101100 + !byte $0D,%10001100 + !byte $0F,%10001100 + !byte $11,%01101100 + !byte $13,%01101100 + !byte $15,%01001100 + !byte $17,%00101100 + !byte $19,%00101100 + !byte $1B,%00001100 + !byte $1D,%11001011 + !byte $1F,%10101011 + !byte $21,%10001011 + !byte $23,%01101011 + !byte $25,%01001011 + !byte $25,%00101011 + !byte $27,%00001011 + !byte $29,%11001010 + !byte $2B,%10001010 + !byte $2D,%01101010 + !byte $2F,%00101010 + !byte $31,%11001001 + !byte $33,%10101001 + !byte $33,%10001001 + !byte $35,%01001001 + !byte $37,%00001001 + !byte $39,%10101000 + !byte $3B,%01001000 + !byte $3D,%00001000 + !byte $3D,%11000111 + !byte $3F,%10000111 + !byte $3F,%01100111 + !byte $41,%00000111 + !byte $43,%10000110 + !byte $43,%01100110 + !byte $45,%00000110 + !byte $45,%11000101 + !byte $47,%01000101 + !byte $47,%00100101 + !byte $49,%10000100 + !byte $49,%01100100 + !byte $49,%01000100 + !byte $4B,%10000011 + !byte $4B,%01100011 + !byte $4B,%01000011 + !byte $4D,%01000010 + !byte $4D,%00100010 + !byte $4D,%00000010 + !byte $4D,%11000001 + !byte $4D,%10100001 + !byte $4D,%10000001 + !byte $01,%11001100 + !byte $03,%11001100 + !byte $05,%11001100 + !byte $07,%11001100 + !byte $09,%11001100 + !byte $0B,%11001100 + !byte $0D,%10101100 + !byte $0F,%10101100 + !byte $11,%10001100 + !byte $13,%10001100 + !byte $15,%01101100 + !byte $17,%01001100 + !byte $19,%01001100 + !byte $1B,%00101100 + !byte $1D,%00001100 + !byte $1F,%11001011 + !byte $21,%10101011 + !byte $23,%10001011 + !byte $25,%01101011 + !byte $27,%00101011 + !byte $29,%00001011 + !byte $2B,%11001010 + !byte $2B,%10101010 + !byte $2D,%10001010 + !byte $2F,%01001010 + !byte $31,%00101010 + !byte $31,%00001010 + !byte $33,%11001001 + !byte $35,%10001001 + !byte $35,%01101001 + !byte $37,%01001001 + !byte $37,%00101001 + !byte $39,%11001000 + !byte $3B,%10001000 + !byte $3B,%01101000 + !byte $3D,%00101000 + !byte $3F,%10100111 + !byte $41,%01000111 + !byte $41,%00100111 + !byte $43,%11000110 + !byte $43,%10100110 + !byte $45,%01000110 + !byte $45,%00100110 + !byte $47,%10100101 + !byte $47,%10000101 + !byte $47,%01100101 + !byte $49,%11000100 + !byte $49,%10100100 + !byte $4B,%00000100 + !byte $4B,%11000011 + !byte $4B,%10100011 + !byte $4D,%00000011 + !byte $4D,%11000010 + !byte $4D,%10100010 + !byte $4D,%10000010 + !byte $4D,%01100010 + !byte $4F,%00000001 + !byte $4F,%11000000 + !byte $4F,%10100000 + !byte $4F,%10000000 + !byte $4F,%01100000 + !byte $4F,%01000000 + !byte $4F,%00100000 + !byte $4F,%00000000 + !byte $01,%00001101 + !byte $03,%00001101 + !byte $05,%00001101 + !byte $07,%00001101 + !byte $09,%00001101 + !byte $0B,%00001101 + !byte $0D,%11001100 + !byte $0F,%11001100 + !byte $11,%10101100 + !byte $13,%10101100 + !byte $15,%10001100 + !byte $17,%01101100 + !byte $19,%01101100 + !byte $1B,%01001100 + !byte $1D,%00101100 + !byte $1F,%00001100 + !byte $21,%11001011 + !byte $23,%10101011 + !byte $25,%10001011 + !byte $27,%01101011 + !byte $27,%01001011 + !byte $29,%00101011 + !byte $2B,%00001011 + !byte $2D,%10101010 + !byte $2F,%10001010 + !byte $2F,%01101010 + !byte $31,%01001010 + !byte $33,%00001010 + !byte $35,%10101001 + !byte $37,%01101001 + !byte $39,%00101001 + !byte $39,%00001001 + !byte $3B,%10101000 + !byte $3D,%01101000 + !byte $3D,%01001000 + !byte $3F,%00001000 + !byte $3F,%11000111 + !byte $41,%10000111 + !byte $41,%01100111 + !byte $43,%00100111 + !byte $43,%00000111 + !byte $45,%10000110 + !byte $45,%01100110 + !byte $47,%00000110 + !byte $47,%11000101 + !byte $49,%01000101 + !byte $49,%00100101 + !byte $49,%00000101 + !byte $4B,%01100100 + !byte $4B,%01000100 + !byte $4B,%00100100 + !byte $4D,%10000011 + !byte $4D,%01100011 + !byte $4D,%01000011 + !byte $4D,%00100011 + !byte $4F,%00100010 + !byte $4F,%00000010 + !byte $4F,%11000001 + !byte $4F,%10100001 + !byte $4F,%10000001 + !byte $4F,%01100001 + !byte $4F,%01000001 + !byte $4F,%00100001 + !byte $01,%00101101 + !byte $03,%00101101 + !byte $05,%00101101 + !byte $07,%00101101 + !byte $09,%00101101 + !byte $0B,%00101101 + !byte $0D,%00001101 + !byte $0F,%00001101 + !byte $11,%11001100 + !byte $13,%11001100 + !byte $15,%10101100 + !byte $17,%10101100 + !byte $17,%10001100 + !byte $19,%10001100 + !byte $1B,%01101100 + !byte $1D,%01001100 + !byte $1F,%00101100 + !byte $21,%00001100 + !byte $23,%11001011 + !byte $25,%10101011 + !byte $27,%10001011 + !byte $29,%01001011 + !byte $2B,%00101011 + !byte $2D,%11001010 + !byte $2F,%10101010 + !byte $31,%01101010 + !byte $33,%00101010 + !byte $35,%00001010 + !byte $35,%11001001 + !byte $37,%10001001 + !byte $39,%01001001 + !byte $3B,%00001001 + !byte $3B,%11001000 + !byte $3D,%10001000 + !byte $3F,%01001000 + !byte $3F,%00101000 + !byte $41,%11000111 + !byte $41,%10100111 + !byte $43,%01000111 + !byte $45,%11000110 + !byte $45,%10100110 + !byte $47,%01000110 + !byte $47,%00100110 + !byte $49,%10000101 + !byte $49,%01100101 + !byte $4B,%11000100 + !byte $4B,%10100100 + !byte $4B,%10000100 + !byte $4D,%00000100 + !byte $4D,%11000011 + !byte $4D,%10100011 + !byte $4F,%11000010 + !byte $4F,%10100010 + !byte $4F,%10000010 + !byte $4F,%01100010 + !byte $4F,%01000010 + !byte $51,%01000000 + !byte $51,%00100000 + !byte $51,%00000000 + !byte $01,%01001101 + !byte $03,%01001101 + !byte $05,%01001101 + !byte $07,%01001101 + !byte $09,%01001101 + !byte $0B,%01001101 + !byte $0D,%00101101 + !byte $0F,%00101101 + !byte $11,%00001101 + !byte $13,%00001101 + !byte $15,%11001100 + !byte $17,%11001100 + !byte $19,%10101100 + !byte $1B,%10001100 + !byte $1D,%01101100 + !byte $1F,%01001100 + !byte $21,%00101100 + !byte $23,%00001100 + !byte $25,%11001011 + !byte $27,%10101011 + !byte $29,%10001011 + !byte $29,%01101011 + !byte $2B,%01001011 + !byte $2D,%00101011 + !byte $2D,%00001011 + !byte $2F,%11001010 + !byte $31,%10101010 + !byte $31,%10001010 + !byte $33,%01101010 + !byte $33,%01001010 + !byte $35,%00101010 + !byte $37,%11001001 + !byte $37,%10101001 + !byte $39,%10001001 + !byte $39,%01101001 + !byte $3B,%00101001 + !byte $3D,%11001000 + !byte $3D,%10101000 + !byte $3F,%01101000 + !byte $41,%00001000 + !byte $43,%10000111 + !byte $43,%01100111 + !byte $45,%00100111 + !byte $45,%00000111 + !byte $47,%10000110 + !byte $47,%01100110 + !byte $49,%00000110 + !byte $49,%11000101 + !byte $49,%10100101 + !byte $4B,%01000101 + !byte $4B,%00100101 + !byte $4B,%00000101 + !byte $4D,%01100100 + !byte $4D,%01000100 + !byte $4D,%00100100 + !byte $4F,%01100011 + !byte $4F,%01000011 + !byte $4F,%00100011 + !byte $4F,%00000011 + !byte $51,%11000001 + !byte $51,%10100001 + !byte $51,%10000001 + !byte $51,%01100001 + !byte $51,%01000001 + !byte $51,%00100001 + !byte $51,%00000001 + !byte $51,%11000000 + !byte $51,%10100000 + !byte $51,%10000000 + !byte $51,%01100000 + !byte $01,%01101101 + !byte $03,%01101101 + !byte $05,%01101101 + !byte $07,%01101101 + !byte $09,%01101101 + !byte $0B,%01101101 + !byte $0D,%01001101 + !byte $0F,%01001101 + !byte $11,%00101101 + !byte $13,%00101101 + !byte $15,%00001101 + !byte $17,%00001101 + !byte $19,%11001100 + !byte $1B,%10101100 + !byte $1D,%10001100 + !byte $1F,%01101100 + !byte $21,%01001100 + !byte $23,%00101100 + !byte $25,%00001100 + !byte $27,%11001011 + !byte $29,%10101011 + !byte $2B,%01101011 + !byte $2D,%01001011 + !byte $2F,%00001011 + !byte $31,%11001010 + !byte $33,%10001010 + !byte $35,%01001010 + !byte $37,%00001010 + !byte $39,%10101001 + !byte $3B,%01101001 + !byte $3B,%01001001 + !byte $3D,%00001001 + !byte $3F,%10101000 + !byte $3F,%10001000 + !byte $41,%01001000 + !byte $41,%00101000 + !byte $43,%11000111 + !byte $43,%10100111 + !byte $45,%01000111 + !byte $47,%11000110 + !byte $47,%10100110 + !byte $49,%01000110 + !byte $49,%00100110 + !byte $4B,%10000101 + !byte $4B,%01100101 + !byte $4D,%11000100 + !byte $4D,%10100100 + !byte $4D,%10000100 + !byte $4F,%11000011 + !byte $4F,%10100011 + !byte $4F,%10000011 + !byte $51,%10100010 + !byte $51,%10000010 + !byte $51,%01100010 + !byte $51,%01000010 + !byte $51,%00100010 + !byte $51,%00000010 + !byte $01,%10001101 + !byte $03,%10001101 + !byte $05,%10001101 + !byte $07,%10001101 + !byte $09,%10001101 + !byte $0B,%10001101 + !byte $0D,%01101101 + !byte $0F,%01101101 + !byte $11,%01001101 + !byte $13,%01001101 + !byte $15,%00101101 + !byte $17,%00101101 + !byte $19,%00001101 + !byte $1B,%11001100 + !byte $1D,%10101100 + !byte $1F,%10001100 + !byte $21,%01101100 + !byte $23,%01001100 + !byte $25,%00101100 + !byte $27,%00001100 + !byte $29,%11001011 + !byte $2B,%10101011 + !byte $2B,%10001011 + !byte $2D,%01101011 + !byte $2F,%01001011 + !byte $2F,%00101011 + !byte $31,%00001011 + !byte $33,%10101010 + !byte $35,%01101010 + !byte $37,%00101010 + !byte $39,%11001001 + !byte $3B,%10001001 + !byte $3D,%01001001 + !byte $3D,%00101001 + !byte $3F,%11001000 + !byte $41,%01101000 + !byte $43,%00101000 + !byte $43,%00001000 + !byte $45,%10000111 + !byte $45,%01100111 + !byte $47,%00100111 + !byte $47,%00000111 + !byte $49,%10000110 + !byte $49,%01100110 + !byte $4B,%11000101 + !byte $4B,%10100101 + !byte $4D,%01000101 + !byte $4D,%00100101 + !byte $4D,%00000101 + !byte $4F,%01000100 + !byte $4F,%00100100 + !byte $4F,%00000100 + !byte $51,%01000011 + !byte $51,%00100011 + !byte $51,%00000011 + !byte $51,%11000010 + !byte $53,%10000001 + !byte $53,%01100001 + !byte $53,%01000001 + !byte $53,%00100001 + !byte $53,%00000001 + !byte $53,%11000000 + !byte $53,%10100000 + !byte $53,%10000000 + !byte $53,%01100000 + !byte $53,%01000000 + !byte $53,%00100000 + !byte $53,%00000000 + !byte $01,%10101101 + !byte $03,%10101101 + !byte $05,%10101101 + !byte $07,%10101101 + !byte $09,%10101101 + !byte $0B,%10101101 + !byte $0D,%10001101 + !byte $0F,%10001101 + !byte $11,%01101101 + !byte $13,%01101101 + !byte $15,%01001101 + !byte $17,%01001101 + !byte $19,%00101101 + !byte $1B,%00001101 + !byte $1D,%11001100 + !byte $1F,%11001100 + !byte $1F,%10101100 + !byte $21,%10101100 + !byte $21,%10001100 + !byte $23,%10001100 + !byte $23,%01101100 + !byte $25,%01001100 + !byte $27,%00101100 + !byte $29,%00001100 + !byte $2B,%11001011 + !byte $2D,%10001011 + !byte $2F,%01101011 + !byte $31,%00101011 + !byte $33,%00001011 + !byte $33,%11001010 + !byte $35,%10101010 + !byte $35,%10001010 + !byte $37,%01101010 + !byte $37,%01001010 + !byte $39,%00101010 + !byte $39,%00001010 + !byte $3B,%11001001 + !byte $3B,%10101001 + !byte $3D,%01101001 + !byte $3F,%00101001 + !byte $3F,%00001001 + !byte $41,%10101000 + !byte $41,%10001000 + !byte $43,%01001000 + !byte $45,%11000111 + !byte $45,%10100111 + !byte $47,%01100111 + !byte $47,%01000111 + !byte $49,%11000110 + !byte $49,%10100110 + !byte $4B,%01000110 + !byte $4B,%00100110 + !byte $4B,%00000110 + !byte $4D,%10000101 + !byte $4D,%01100101 + !byte $4F,%10100100 + !byte $4F,%10000100 + !byte $4F,%01100100 + !byte $51,%10100011 + !byte $51,%10000011 + !byte $51,%01100011 + !byte $53,%01100010 + !byte $53,%01000010 + !byte $53,%00100010 + !byte $53,%00000010 + !byte $53,%11000001 + !byte $53,%10100001 + !byte $01,%11001101 + !byte $03,%11001101 + !byte $05,%11001101 + !byte $07,%11001101 + !byte $09,%11001101 + !byte $0B,%11001101 + !byte $0D,%10101101 + !byte $0F,%10101101 + !byte $11,%10001101 + !byte $13,%10001101 + !byte $15,%01101101 + !byte $17,%01101101 + !byte $19,%01001101 + !byte $1B,%00101101 + !byte $1D,%00101101 + !byte $1D,%00001101 + !byte $1F,%00001101 + !byte $21,%11001100 + !byte $23,%10101100 + !byte $25,%10001100 + !byte $25,%01101100 + !byte $27,%01001100 + !byte $29,%00101100 + !byte $2B,%00001100 + !byte $2D,%11001011 + !byte $2D,%10101011 + !byte $2F,%10001011 + !byte $31,%01001011 + !byte $33,%00101011 + !byte $35,%11001010 + !byte $37,%10001010 + !byte $39,%01001010 + !byte $3B,%00001010 + !byte $3D,%10101001 + !byte $3D,%10001001 + !byte $3F,%01001001 + !byte $41,%00001001 + !byte $41,%11001000 + !byte $43,%10001000 + !byte $43,%01101000 + !byte $45,%00101000 + !byte $45,%00001000 + !byte $47,%10000111 + !byte $49,%00100111 + !byte $49,%00000111 + !byte $4B,%10000110 + !byte $4B,%01100110 + !byte $4D,%11000101 + !byte $4D,%10100101 + !byte $4F,%00100101 + !byte $4F,%00000101 + !byte $4F,%11000100 + !byte $51,%01000100 + !byte $51,%00100100 + !byte $51,%00000100 + !byte $51,%11000011 + !byte $53,%00100011 + !byte $53,%00000011 + !byte $53,%11000010 + !byte $53,%10100010 + !byte $53,%10000010 + !byte $55,%00100001 + !byte $55,%00000001 + !byte $55,%11000000 + !byte $55,%10100000 + !byte $55,%10000000 + !byte $55,%01100000 + !byte $55,%01000000 + !byte $55,%00100000 + !byte $55,%00000000 + !byte $01,%00001110 + !byte $03,%00001110 + !byte $05,%00001110 + !byte $07,%00001110 + !byte $09,%00001110 + !byte $0B,%00001110 + !byte $0D,%11001101 + !byte $0F,%11001101 + !byte $11,%10101101 + !byte $13,%10101101 + !byte $15,%10001101 + !byte $17,%10001101 + !byte $19,%01101101 + !byte $1B,%01001101 + !byte $1D,%01001101 + !byte $1F,%00101101 + !byte $21,%00001101 + !byte $23,%11001100 + !byte $25,%10101100 + !byte $27,%10001100 + !byte $27,%01101100 + !byte $29,%01001100 + !byte $2B,%00101100 + !byte $2D,%00001100 + !byte $2F,%10101011 + !byte $31,%10001011 + !byte $31,%01101011 + !byte $33,%01001011 + !byte $35,%00001011 + !byte $37,%10101010 + !byte $39,%01101010 + !byte $3B,%00101010 + !byte $3D,%11001001 + !byte $3F,%10001001 + !byte $3F,%01101001 + !byte $41,%00101001 + !byte $43,%10101000 + !byte $45,%01001000 + !byte $47,%11000111 + !byte $47,%10100111 + !byte $49,%01100111 + !byte $49,%01000111 + !byte $4B,%11000110 + !byte $4B,%10100110 + !byte $4D,%01000110 + !byte $4D,%00100110 + !byte $4D,%00000110 + !byte $4F,%10000101 + !byte $4F,%01100101 + !byte $4F,%01000101 + !byte $51,%10100100 + !byte $51,%10000100 + !byte $51,%01100100 + !byte $53,%10100011 + !byte $53,%10000011 + !byte $53,%01100011 + !byte $53,%01000011 + !byte $55,%01000010 + !byte $55,%00100010 + !byte $55,%00000010 + !byte $55,%11000001 + !byte $55,%10100001 + !byte $55,%10000001 + !byte $55,%01100001 + !byte $55,%01000001 + !byte $01,%00101110 + !byte $03,%00101110 + !byte $05,%00101110 + !byte $07,%00101110 + !byte $09,%00101110 + !byte $0B,%00101110 + !byte $0D,%00001110 + !byte $0F,%00001110 + !byte $11,%11001101 + !byte $13,%11001101 + !byte $15,%10101101 + !byte $17,%10101101 + !byte $19,%10001101 + !byte $1B,%01101101 + !byte $1D,%01101101 + !byte $1F,%01001101 + !byte $21,%00101101 + !byte $23,%00001101 + !byte $25,%11001100 + !byte $27,%10101100 + !byte $29,%01101100 + !byte $2B,%01001100 + !byte $2D,%00101100 + !byte $2F,%11001011 + !byte $31,%10101011 + !byte $33,%01101011 + !byte $35,%01001011 + !byte $35,%00101011 + !byte $37,%00001011 + !byte $37,%11001010 + !byte $39,%10101010 + !byte $39,%10001010 + !byte $3B,%01101010 + !byte $3B,%01001010 + !byte $3D,%00101010 + !byte $3D,%00001010 + !byte $3F,%10101001 + !byte $41,%01101001 + !byte $41,%01001001 + !byte $43,%00001001 + !byte $43,%11001000 + !byte $45,%10001000 + !byte $45,%01101000 + !byte $47,%00101000 + !byte $47,%00001000 + !byte $49,%10100111 + !byte $49,%10000111 + !byte $4B,%00100111 + !byte $4B,%00000111 + !byte $4D,%10000110 + !byte $4D,%01100110 + !byte $4F,%11000101 + !byte $4F,%10100101 + !byte $51,%00100101 + !byte $51,%00000101 + !byte $51,%11000100 + !byte $53,%00100100 + !byte $53,%00000100 + !byte $53,%11000011 + !byte $55,%00000011 + !byte $55,%11000010 + !byte $55,%10100010 + !byte $55,%10000010 + !byte $55,%01100010 + !byte $57,%10100000 + !byte $57,%10000000 + !byte $57,%01100000 + !byte $57,%01000000 + !byte $57,%00100000 + !byte $57,%00000000 + !byte $01,%01001110 + !byte $03,%01001110 + !byte $05,%01001110 + !byte $07,%01001110 + !byte $09,%01001110 + !byte $0B,%01001110 + !byte $0D,%00101110 + !byte $0F,%00101110 + !byte $11,%00101110 + !byte $11,%00001110 + !byte $13,%00001110 + !byte $15,%11001101 + !byte $17,%11001101 + !byte $19,%10101101 + !byte $1B,%10001101 + !byte $1D,%10001101 + !byte $1F,%01101101 + !byte $21,%01001101 + !byte $23,%00101101 + !byte $25,%00001101 + !byte $27,%11001100 + !byte $29,%10101100 + !byte $29,%10001100 + !byte $2B,%01101100 + !byte $2D,%01001100 + !byte $2F,%00101100 + !byte $2F,%00001100 + !byte $31,%11001011 + !byte $33,%10001011 + !byte $35,%01101011 + !byte $37,%00101011 + !byte $39,%11001010 + !byte $3B,%10001010 + !byte $3D,%01001010 + !byte $3F,%00001010 + !byte $3F,%11001001 + !byte $41,%10001001 + !byte $43,%00101001 + !byte $45,%11001000 + !byte $45,%10101000 + !byte $47,%01101000 + !byte $47,%01001000 + !byte $49,%11000111 + !byte $4B,%01100111 + !byte $4B,%01000111 + !byte $4D,%11000110 + !byte $4D,%10100110 + !byte $4F,%00100110 + !byte $4F,%00000110 + !byte $51,%01100101 + !byte $51,%01000101 + !byte $53,%10000100 + !byte $53,%01100100 + !byte $53,%01000100 + !byte $55,%10000011 + !byte $55,%01100011 + !byte $55,%01000011 + !byte $55,%00100011 + !byte $57,%00000010 + !byte $57,%11000001 + !byte $57,%10100001 + !byte $57,%10000001 + !byte $57,%01100001 + !byte $57,%01000001 + !byte $57,%00100001 + !byte $57,%00000001 + !byte $57,%11000000 + !byte $01,%01101110 + !byte $03,%01101110 + !byte $05,%01101110 + !byte $07,%01101110 + !byte $09,%01101110 + !byte $0B,%01101110 + !byte $0D,%01001110 + !byte $0F,%01001110 + !byte $11,%01001110 + !byte $13,%00101110 + !byte $15,%00101110 + !byte $15,%00001110 + !byte $17,%00001110 + !byte $19,%11001101 + !byte $1B,%11001101 + !byte $1B,%10101101 + !byte $1D,%10101101 + !byte $1F,%10001101 + !byte $21,%01101101 + !byte $23,%01001101 + !byte $25,%00101101 + !byte $27,%00001101 + !byte $29,%11001100 + !byte $2B,%10101100 + !byte $2B,%10001100 + !byte $2D,%01101100 + !byte $2F,%01001100 + !byte $31,%00001100 + !byte $33,%11001011 + !byte $33,%10101011 + !byte $35,%10001011 + !byte $37,%01001011 + !byte $39,%00001011 + !byte $3B,%10101010 + !byte $3D,%01101010 + !byte $3F,%00101010 + !byte $41,%11001001 + !byte $41,%10101001 + !byte $43,%01101001 + !byte $43,%01001001 + !byte $45,%00001001 + !byte $47,%10001000 + !byte $49,%00101000 + !byte $49,%00001000 + !byte $4B,%10100111 + !byte $4B,%10000111 + !byte $4D,%00100111 + !byte $4D,%00000111 + !byte $4F,%10000110 + !byte $4F,%01100110 + !byte $4F,%01000110 + !byte $51,%11000101 + !byte $51,%10100101 + !byte $51,%10000101 + !byte $53,%00000101 + !byte $53,%11000100 + !byte $53,%10100100 + !byte $55,%00100100 + !byte $55,%00000100 + !byte $55,%11000011 + !byte $55,%10100011 + !byte $57,%11000010 + !byte $57,%10100010 + !byte $57,%10000010 + !byte $57,%01100010 + !byte $57,%01000010 + !byte $57,%00100010 + !byte $01,%10001110 + !byte $03,%10001110 + !byte $05,%10001110 + !byte $07,%10001110 + !byte $09,%10001110 + !byte $0B,%10001110 + !byte $0D,%01101110 + !byte $0F,%01101110 + !byte $11,%01101110 + !byte $13,%01001110 + !byte $15,%01001110 + !byte $17,%00101110 + !byte $19,%00001110 + !byte $1B,%00001110 + !byte $1D,%11001101 + !byte $1F,%10101101 + !byte $21,%10001101 + !byte $23,%01101101 + !byte $25,%01001101 + !byte $27,%00101101 + !byte $29,%00001101 + !byte $2B,%11001100 + !byte $2D,%10001100 + !byte $2F,%01101100 + !byte $31,%00101100 + !byte $33,%00001100 + !byte $35,%10101011 + !byte $37,%01101011 + !byte $39,%01001011 + !byte $39,%00101011 + !byte $3B,%00001011 + !byte $3B,%11001010 + !byte $3D,%10101010 + !byte $3D,%10001010 + !byte $3F,%01001010 + !byte $41,%00001010 + !byte $43,%10101001 + !byte $43,%10001001 + !byte $45,%01001001 + !byte $45,%00101001 + !byte $47,%11001000 + !byte $47,%10101000 + !byte $49,%01101000 + !byte $49,%01001000 + !byte $4B,%00001000 + !byte $4B,%11000111 + !byte $4D,%01100111 + !byte $4D,%01000111 + !byte $4F,%11000110 + !byte $4F,%10100110 + !byte $51,%00100110 + !byte $51,%00000110 + !byte $53,%01100101 + !byte $53,%01000101 + !byte $53,%00100101 + !byte $55,%10000100 + !byte $55,%01100100 + !byte $55,%01000100 + !byte $57,%01100011 + !byte $57,%01000011 + !byte $57,%00100011 + !byte $57,%00000011 + !byte $59,%10100001 + !byte $59,%10000001 + !byte $59,%01100001 + !byte $59,%01000001 + !byte $59,%00100001 + !byte $59,%00000001 + !byte $59,%11000000 + !byte $59,%10100000 + !byte $59,%10000000 + !byte $59,%01100000 + !byte $59,%01000000 + !byte $59,%00100000 + !byte $59,%00000000 + !byte $01,%10101110 + !byte $03,%10101110 + !byte $05,%10101110 + !byte $07,%10101110 + !byte $09,%10101110 + !byte $0B,%10101110 + !byte $0D,%10001110 + !byte $0F,%10001110 + !byte $11,%10001110 + !byte $13,%01101110 + !byte $15,%01101110 + !byte $17,%01001110 + !byte $19,%00101110 + !byte $1B,%00101110 + !byte $1D,%00001110 + !byte $1F,%11001101 + !byte $21,%10101101 + !byte $23,%10001101 + !byte $25,%01101101 + !byte $27,%01001101 + !byte $29,%00101101 + !byte $2B,%00001101 + !byte $2D,%11001100 + !byte $2D,%10101100 + !byte $2F,%10001100 + !byte $31,%01101100 + !byte $31,%01001100 + !byte $33,%00101100 + !byte $35,%00001100 + !byte $35,%11001011 + !byte $37,%10101011 + !byte $37,%10001011 + !byte $39,%01101011 + !byte $3B,%00101011 + !byte $3D,%11001010 + !byte $3F,%10001010 + !byte $3F,%01101010 + !byte $41,%01001010 + !byte $41,%00101010 + !byte $43,%11001001 + !byte $45,%01101001 + !byte $47,%00101001 + !byte $47,%00001001 + !byte $49,%10101000 + !byte $49,%10001000 + !byte $4B,%00101000 + !byte $4D,%10100111 + !byte $4D,%10000111 + !byte $4F,%00100111 + !byte $4F,%00000111 + !byte $51,%10000110 + !byte $51,%01100110 + !byte $51,%01000110 + !byte $53,%11000101 + !byte $53,%10100101 + !byte $53,%10000101 + !byte $55,%00000101 + !byte $55,%11000100 + !byte $55,%10100100 + !byte $57,%00000100 + !byte $57,%11000011 + !byte $57,%10100011 + !byte $57,%10000011 + !byte $59,%10100010 + !byte $59,%10000010 + !byte $59,%01100010 + !byte $59,%01000010 + !byte $59,%00100010 + !byte $59,%00000010 + !byte $59,%11000001 + !byte $01,%11001110 + !byte $03,%11001110 + !byte $05,%11001110 + !byte $07,%11001110 + !byte $09,%11001110 + !byte $0B,%11001110 + !byte $0D,%10101110 + !byte $0F,%10101110 + !byte $11,%10101110 + !byte $13,%10001110 + !byte $15,%10001110 + !byte $17,%01101110 + !byte $19,%01001110 + !byte $1B,%01001110 + !byte $1D,%00101110 + !byte $1F,%00001110 + !byte $21,%11001101 + !byte $23,%10101101 + !byte $25,%10001101 + !byte $27,%01101101 + !byte $29,%01001101 + !byte $2B,%00101101 + !byte $2D,%00001101 + !byte $2F,%10101100 + !byte $31,%10001100 + !byte $33,%01001100 + !byte $35,%00101100 + !byte $37,%11001011 + !byte $39,%10001011 + !byte $3B,%01001011 + !byte $3D,%00001011 + !byte $3F,%10101010 + !byte $41,%01101010 + !byte $43,%00101010 + !byte $43,%00001010 + !byte $45,%10101001 + !byte $45,%10001001 + !byte $47,%01001001 + !byte $49,%11001000 + !byte $4B,%01101000 + !byte $4B,%01001000 + !byte $4D,%00001000 + !byte $4D,%11000111 + !byte $4F,%01100111 + !byte $4F,%01000111 + !byte $51,%11000110 + !byte $51,%10100110 + !byte $53,%00100110 + !byte $53,%00000110 + !byte $55,%01100101 + !byte $55,%01000101 + !byte $55,%00100101 + !byte $57,%01100100 + !byte $57,%01000100 + !byte $57,%00100100 + !byte $59,%01000011 + !byte $59,%00100011 + !byte $59,%00000011 + !byte $59,%11000010 + !byte $5B,%01100001 + !byte $5B,%01000001 + !byte $5B,%00100001 + !byte $5B,%00000001 + !byte $5B,%11000000 + !byte $5B,%10100000 + !byte $5B,%10000000 + !byte $5B,%01100000 + !byte $5B,%01000000 + !byte $5B,%00100000 + !byte $5B,%00000000 + !byte $01,%00001111 + !byte $03,%00001111 + !byte $05,%00001111 + !byte $07,%00001111 + !byte $09,%00001111 + !byte $0B,%00001111 + !byte $0D,%11001110 + !byte $0F,%11001110 + !byte $11,%11001110 + !byte $13,%10101110 + !byte $15,%10101110 + !byte $17,%10001110 + !byte $19,%01101110 + !byte $1B,%01101110 + !byte $1D,%01001110 + !byte $1F,%00101110 + !byte $21,%00001110 + !byte $23,%11001101 + !byte $25,%10101101 + !byte $27,%10001101 + !byte $29,%01101101 + !byte $2B,%01001101 + !byte $2D,%00101101 + !byte $2F,%00001101 + !byte $2F,%11001100 + !byte $31,%10101100 + !byte $33,%10001100 + !byte $33,%01101100 + !byte $35,%01001100 + !byte $37,%00001100 + !byte $39,%11001011 + !byte $39,%10101011 + !byte $3B,%10001011 + !byte $3B,%01101011 + !byte $3D,%01001011 + !byte $3D,%00101011 + !byte $3F,%00001011 + !byte $3F,%11001010 + !byte $41,%10001010 + !byte $43,%01001010 + !byte $45,%00001010 + !byte $45,%11001001 + !byte $47,%10001001 + !byte $47,%01101001 + !byte $49,%00101001 + !byte $49,%00001001 + !byte $4B,%10101000 + !byte $4B,%10001000 + !byte $4D,%01001000 + !byte $4D,%00101000 + !byte $4F,%10100111 + !byte $4F,%10000111 + !byte $51,%00100111 + !byte $51,%00000111 + !byte $53,%01100110 + !byte $53,%01000110 + !byte $55,%10100101 + !byte $55,%10000101 + !byte $57,%00000101 + !byte $57,%11000100 + !byte $57,%10100100 + !byte $57,%10000100 + !byte $59,%11000011 + !byte $59,%10100011 + !byte $59,%10000011 + !byte $59,%01100011 + !byte $5B,%01100010 + !byte $5B,%01000010 + !byte $5B,%00100010 + !byte $5B,%00000010 + !byte $5B,%11000001 + !byte $5B,%10100001 + !byte $5B,%10000001 + !byte $01,%00101111 + !byte $03,%00101111 + !byte $05,%00101111 + !byte $07,%00101111 + !byte $09,%00101111 + !byte $0B,%00101111 + !byte $0D,%00001111 + !byte $0F,%00001111 + !byte $11,%00001111 + !byte $13,%11001110 + !byte $15,%11001110 + !byte $17,%10101110 + !byte $19,%10001110 + !byte $1B,%10001110 + !byte $1D,%01101110 + !byte $1F,%01001110 + !byte $21,%00101110 + !byte $23,%00001110 + !byte $25,%00001110 + !byte $25,%11001101 + !byte $27,%10101101 + !byte $29,%10001101 + !byte $2B,%01101101 + !byte $2D,%01001101 + !byte $2F,%00101101 + !byte $31,%11001100 + !byte $33,%10101100 + !byte $35,%01101100 + !byte $37,%01001100 + !byte $37,%00101100 + !byte $39,%00001100 + !byte $3B,%10101011 + !byte $3D,%01101011 + !byte $3F,%00101011 + !byte $41,%11001010 + !byte $41,%10101010 + !byte $43,%01101010 + !byte $45,%00101010 + !byte $47,%11001001 + !byte $47,%10101001 + !byte $49,%01101001 + !byte $49,%01001001 + !byte $4B,%00001001 + !byte $4B,%11001000 + !byte $4D,%01101000 + !byte $4F,%00001000 + !byte $4F,%11000111 + !byte $51,%01100111 + !byte $51,%01000111 + !byte $53,%11000110 + !byte $53,%10100110 + !byte $53,%10000110 + !byte $55,%00100110 + !byte $55,%00000110 + !byte $55,%11000101 + !byte $57,%01000101 + !byte $57,%00100101 + !byte $59,%01100100 + !byte $59,%01000100 + !byte $59,%00100100 + !byte $59,%00000100 + !byte $5B,%00100011 + !byte $5B,%00000011 + !byte $5B,%11000010 + !byte $5B,%10100010 + !byte $5B,%10000010 + !byte $5D,%11000000 + !byte $5D,%10100000 + !byte $5D,%10000000 + !byte $5D,%01100000 + !byte $5D,%01000000 + !byte $5D,%00100000 + !byte $5D,%00000000 + !byte $01,%01001111 + !byte $03,%01001111 + !byte $05,%01001111 + !byte $07,%01001111 + !byte $09,%01001111 + !byte $0B,%01001111 + !byte $0D,%00101111 + !byte $0F,%00101111 + !byte $11,%00101111 + !byte $13,%00001111 + !byte $15,%00001111 + !byte $17,%11001110 + !byte $19,%11001110 + !byte $19,%10101110 + !byte $1B,%10101110 + !byte $1D,%10001110 + !byte $1F,%01101110 + !byte $21,%01001110 + !byte $23,%01001110 + !byte $23,%00101110 + !byte $25,%00101110 + !byte $27,%00001110 + !byte $27,%11001101 + !byte $29,%10101101 + !byte $2B,%10001101 + !byte $2D,%01101101 + !byte $2F,%01001101 + !byte $31,%00001101 + !byte $33,%11001100 + !byte $35,%10001100 + !byte $37,%01101100 + !byte $39,%00101100 + !byte $3B,%11001011 + !byte $3D,%10001011 + !byte $3F,%01001011 + !byte $41,%00001011 + !byte $43,%10101010 + !byte $43,%10001010 + !byte $45,%01001010 + !byte $47,%00001010 + !byte $49,%10001001 + !byte $4B,%00101001 + !byte $4D,%10101000 + !byte $4D,%10001000 + !byte $4F,%01001000 + !byte $4F,%00101000 + !byte $51,%10100111 + !byte $51,%10000111 + !byte $53,%00100111 + !byte $53,%00000111 + !byte $55,%01100110 + !byte $55,%01000110 + !byte $57,%10100101 + !byte $57,%10000101 + !byte $57,%01100101 + !byte $59,%11000100 + !byte $59,%10100100 + !byte $59,%10000100 + !byte $5B,%10100011 + !byte $5B,%10000011 + !byte $5B,%01100011 + !byte $5B,%01000011 + !byte $5D,%00100010 + !byte $5D,%00000010 + !byte $5D,%11000001 + !byte $5D,%10100001 + !byte $5D,%10000001 + !byte $5D,%01100001 + !byte $5D,%01000001 + !byte $5D,%00100001 + !byte $5D,%00000001 + !byte $01,%01101111 + !byte $03,%01101111 + !byte $05,%01101111 + !byte $07,%01101111 + !byte $09,%01101111 + !byte $0B,%01101111 + !byte $0D,%01001111 + !byte $0F,%01001111 + !byte $11,%01001111 + !byte $13,%00101111 + !byte $15,%00101111 + !byte $17,%00001111 + !byte $19,%00001111 + !byte $1B,%11001110 + !byte $1D,%10101110 + !byte $1F,%10001110 + !byte $21,%10001110 + !byte $21,%01101110 + !byte $23,%01101110 + !byte $25,%01001110 + !byte $27,%00101110 + !byte $29,%00001110 + !byte $29,%11001101 + !byte $2B,%10101101 + !byte $2D,%10001101 + !byte $2F,%01101101 + !byte $31,%01001101 + !byte $31,%00101101 + !byte $33,%00001101 + !byte $35,%11001100 + !byte $35,%10101100 + !byte $37,%10001100 + !byte $39,%01001100 + !byte $3B,%00101100 + !byte $3B,%00001100 + !byte $3D,%11001011 + !byte $3D,%10101011 + !byte $3F,%10001011 + !byte $3F,%01101011 + !byte $41,%01001011 + !byte $41,%00101011 + !byte $43,%11001010 + !byte $45,%10001010 + !byte $45,%01101010 + !byte $47,%00101010 + !byte $49,%11001001 + !byte $49,%10101001 + !byte $4B,%01101001 + !byte $4B,%01001001 + !byte $4D,%00001001 + !byte $4D,%11001000 + !byte $4F,%01101000 + !byte $51,%00001000 + !byte $51,%11000111 + !byte $53,%01100111 + !byte $53,%01000111 + !byte $55,%11000110 + !byte $55,%10100110 + !byte $55,%10000110 + !byte $57,%00100110 + !byte $57,%00000110 + !byte $57,%11000101 + !byte $59,%01000101 + !byte $59,%00100101 + !byte $59,%00000101 + !byte $5B,%01000100 + !byte $5B,%00100100 + !byte $5B,%00000100 + !byte $5B,%11000011 + !byte $5D,%00000011 + !byte $5D,%11000010 + !byte $5D,%10100010 + !byte $5D,%10000010 + !byte $5D,%01100010 + !byte $5D,%01000010 + !byte $01,%10001111 + !byte $03,%10001111 + !byte $05,%10001111 + !byte $07,%10001111 + !byte $09,%10001111 + !byte $0B,%10001111 + !byte $0D,%01101111 + !byte $0F,%01101111 + !byte $11,%01101111 + !byte $13,%01001111 + !byte $15,%01001111 + !byte $17,%00101111 + !byte $19,%00101111 + !byte $1B,%00001111 + !byte $1D,%11001110 + !byte $1F,%10101110 + !byte $21,%10101110 + !byte $23,%10001110 + !byte $25,%01101110 + !byte $27,%01001110 + !byte $29,%00101110 + !byte $2B,%00001110 + !byte $2B,%11001101 + !byte $2D,%10101101 + !byte $2F,%10001101 + !byte $31,%01101101 + !byte $33,%00101101 + !byte $35,%00001101 + !byte $37,%10101100 + !byte $39,%10001100 + !byte $39,%01101100 + !byte $3B,%01001100 + !byte $3D,%00001100 + !byte $3F,%10101011 + !byte $41,%01101011 + !byte $43,%00101011 + !byte $43,%00001011 + !byte $45,%10101010 + !byte $47,%01101010 + !byte $47,%01001010 + !byte $49,%00001010 + !byte $4B,%10101001 + !byte $4B,%10001001 + !byte $4D,%01001001 + !byte $4D,%00101001 + !byte $4F,%10101000 + !byte $4F,%10001000 + !byte $51,%01001000 + !byte $51,%00101000 + !byte $53,%10100111 + !byte $53,%10000111 + !byte $55,%00100111 + !byte $55,%00000111 + !byte $57,%01100110 + !byte $57,%01000110 + !byte $59,%10100101 + !byte $59,%10000101 + !byte $59,%01100101 + !byte $5B,%10100100 + !byte $5B,%10000100 + !byte $5B,%01100100 + !byte $5D,%10000011 + !byte $5D,%01100011 + !byte $5D,%01000011 + !byte $5D,%00100011 + !byte $5F,%11000001 + !byte $5F,%10100001 + !byte $5F,%10000001 + !byte $5F,%01100001 + !byte $5F,%01000001 + !byte $5F,%00100001 + !byte $5F,%00000001 + !byte $5F,%11000000 + !byte $5F,%10100000 + !byte $5F,%10000000 + !byte $5F,%01100000 + !byte $5F,%01000000 + !byte $5F,%00100000 + !byte $5F,%00000000 + !byte $01,%10101111 + !byte $03,%10101111 + !byte $05,%10101111 + !byte $07,%10101111 + !byte $09,%10101111 + !byte $0B,%10101111 + !byte $0D,%10001111 + !byte $0F,%10001111 + !byte $11,%10001111 + !byte $13,%01101111 + !byte $15,%01101111 + !byte $17,%01001111 + !byte $19,%01001111 + !byte $1B,%00101111 + !byte $1D,%00001111 + !byte $1F,%11001110 + !byte $21,%11001110 + !byte $23,%10101110 + !byte $25,%10001110 + !byte $27,%01101110 + !byte $29,%01001110 + !byte $2B,%00101110 + !byte $2D,%00001110 + !byte $2D,%11001101 + !byte $2F,%10101101 + !byte $31,%10001101 + !byte $33,%01001101 + !byte $35,%00101101 + !byte $37,%11001100 + !byte $39,%10101100 + !byte $3B,%01101100 + !byte $3D,%00101100 + !byte $3F,%11001011 + !byte $41,%10001011 + !byte $43,%01001011 + !byte $45,%00001011 + !byte $45,%11001010 + !byte $47,%10001010 + !byte $49,%01001010 + !byte $49,%00101010 + !byte $4B,%11001001 + !byte $4D,%01101001 + !byte $4F,%00001001 + !byte $4F,%11001000 + !byte $51,%10001000 + !byte $51,%01101000 + !byte $53,%00001000 + !byte $53,%11000111 + !byte $55,%01100111 + !byte $55,%01000111 + !byte $57,%10100110 + !byte $57,%10000110 + !byte $59,%00000110 + !byte $59,%11000101 + !byte $5B,%00100101 + !byte $5B,%00000101 + !byte $5B,%11000100 + !byte $5D,%00100100 + !byte $5D,%00000100 + !byte $5D,%11000011 + !byte $5D,%10100011 + !byte $5F,%10100010 + !byte $5F,%10000010 + !byte $5F,%01100010 + !byte $5F,%01000010 + !byte $5F,%00100010 + !byte $5F,%00000010 + !byte $01,%11001111 + !byte $03,%11001111 + !byte $05,%11001111 + !byte $07,%11001111 + !byte $09,%11001111 + !byte $0B,%11001111 + !byte $0D,%10101111 + !byte $0F,%10101111 + !byte $11,%10101111 + !byte $13,%10001111 + !byte $15,%10001111 + !byte $17,%01101111 + !byte $19,%01101111 + !byte $1B,%01001111 + !byte $1D,%00101111 + !byte $1F,%00101111 + !byte $1F,%00001111 + !byte $21,%00001111 + !byte $23,%11001110 + !byte $25,%10101110 + !byte $27,%10001110 + !byte $29,%01101110 + !byte $2B,%01001110 + !byte $2D,%00101110 + !byte $2F,%11001101 + !byte $31,%10101101 + !byte $33,%10001101 + !byte $33,%01101101 + !byte $35,%01001101 + !byte $37,%00101101 + !byte $37,%00001101 + !byte $39,%11001100 + !byte $3B,%10001100 + !byte $3D,%01101100 + !byte $3D,%01001100 + !byte $3F,%00101100 + !byte $3F,%00001100 + !byte $41,%11001011 + !byte $41,%10101011 + !byte $43,%10001011 + !byte $43,%01101011 + !byte $45,%00101011 + !byte $47,%11001010 + !byte $47,%10101010 + !byte $49,%01101010 + !byte $4B,%00101010 + !byte $4B,%00001010 + !byte $4D,%10101001 + !byte $4D,%10001001 + !byte $4F,%01001001 + !byte $4F,%00101001 + !byte $51,%10101000 + !byte $53,%01001000 + !byte $53,%00101000 + !byte $55,%10100111 + !byte $55,%10000111 + !byte $57,%00100111 + !byte $57,%00000111 + !byte $57,%11000110 + !byte $59,%01100110 + !byte $59,%01000110 + !byte $59,%00100110 + !byte $5B,%10000101 + !byte $5B,%01100101 + !byte $5B,%01000101 + !byte $5D,%10100100 + !byte $5D,%10000100 + !byte $5D,%01100100 + !byte $5D,%01000100 + !byte $5F,%01100011 + !byte $5F,%01000011 + !byte $5F,%00100011 + !byte $5F,%00000011 + !byte $5F,%11000010 + !byte $01,%00010000 + !byte $03,%00010000 + !byte $05,%00010000 + !byte $07,%00010000 + !byte $09,%00010000 + !byte $0B,%00010000 + !byte $0D,%11001111 + !byte $0F,%11001111 + !byte $11,%11001111 + !byte $13,%10101111 + !byte $15,%10101111 + !byte $17,%10001111 + !byte $19,%10001111 + !byte $1B,%01101111 + !byte $1D,%01001111 + !byte $1F,%01001111 + !byte $21,%00101111 + !byte $23,%00001111 + !byte $25,%11001110 + !byte $27,%10101110 + !byte $29,%10001110 + !byte $2B,%01101110 + !byte $2D,%01001110 + !byte $2F,%00101110 + !byte $2F,%00001110 + !byte $31,%11001101 + !byte $33,%10101101 + !byte $35,%01101101 + !byte $37,%01001101 + !byte $39,%00001101 + !byte $3B,%11001100 + !byte $3B,%10101100 + !byte $3D,%10001100 + !byte $3F,%01001100 + !byte $41,%00001100 + !byte $43,%10101011 + !byte $45,%01101011 + !byte $45,%01001011 + !byte $47,%00001011 + !byte $49,%10101010 + !byte $49,%10001010 + !byte $4B,%01001010 + !byte $4D,%11001001 + !byte $4F,%01101001 + !byte $51,%00001001 + !byte $51,%11001000 + !byte $53,%10001000 + !byte $53,%01101000 + !byte $55,%00001000 + !byte $55,%11000111 + !byte $57,%01100111 + !byte $57,%01000111 + !byte $59,%10100110 + !byte $59,%10000110 + !byte $5B,%00000110 + !byte $5B,%11000101 + !byte $5B,%10100101 + !byte $5D,%00100101 + !byte $5D,%00000101 + !byte $5D,%11000100 + !byte $5F,%00000100 + !byte $5F,%11000011 + !byte $5F,%10100011 + !byte $5F,%10000011 + !byte $01,%00110000 + !byte $03,%00110000 + !byte $05,%00110000 + !byte $07,%00110000 + !byte $09,%00110000 + !byte $0B,%00110000 + !byte $0D,%00010000 + !byte $0F,%00010000 + !byte $11,%00010000 + !byte $13,%11001111 + !byte $15,%11001111 + !byte $17,%10101111 + !byte $19,%10101111 + !byte $1B,%10001111 + !byte $1D,%01101111 + !byte $1F,%01101111 + !byte $21,%01001111 + !byte $23,%00101111 + !byte $25,%00001111 + !byte $27,%11001110 + !byte $29,%10101110 + !byte $2B,%10001110 + !byte $2D,%01101110 + !byte $2F,%01001110 + !byte $31,%00001110 + !byte $33,%11001101 + !byte $35,%10101101 + !byte $35,%10001101 + !byte $37,%01101101 + !byte $39,%01001101 + !byte $39,%00101101 + !byte $3B,%00001101 + !byte $3D,%10101100 + !byte $3F,%01101100 + !byte $41,%00101100 + !byte $43,%11001011 + !byte $45,%10001011 + !byte $47,%01001011 + !byte $47,%00101011 + !byte $49,%11001010 + !byte $4B,%10001010 + !byte $4B,%01101010 + !byte $4D,%00101010 + !byte $4D,%00001010 + !byte $4F,%10101001 + !byte $4F,%10001001 + !byte $51,%01001001 + !byte $51,%00101001 + !byte $53,%11001000 + !byte $53,%10101000 + !byte $55,%01001000 + !byte $55,%00101000 + !byte $57,%10100111 + !byte $57,%10000111 + !byte $59,%00100111 + !byte $59,%00000111 + !byte $59,%11000110 + !byte $5B,%01100110 + !byte $5B,%01000110 + !byte $5B,%00100110 + !byte $5D,%10000101 + !byte $5D,%01100101 + !byte $5D,%01000101 + !byte $5F,%10000100 + !byte $5F,%01100100 + !byte $5F,%01000100 + !byte $5F,%00100100 + !byte $01,%01010000 + !byte $03,%01010000 + !byte $05,%01010000 + !byte $07,%01010000 + !byte $09,%01010000 + !byte $0B,%01010000 + !byte $0D,%00110000 + !byte $0F,%00110000 + !byte $11,%00110000 + !byte $13,%00010000 + !byte $15,%00010000 + !byte $17,%11001111 + !byte $19,%11001111 + !byte $1B,%10101111 + !byte $1D,%10001111 + !byte $1F,%10001111 + !byte $21,%01101111 + !byte $23,%01001111 + !byte $25,%00101111 + !byte $27,%00001111 + !byte $29,%11001110 + !byte $2B,%10101110 + !byte $2D,%10001110 + !byte $2F,%01101110 + !byte $31,%01001110 + !byte $31,%00101110 + !byte $33,%00001110 + !byte $35,%11001101 + !byte $37,%10001101 + !byte $39,%01101101 + !byte $3B,%00101101 + !byte $3D,%11001100 + !byte $3F,%10101100 + !byte $3F,%10001100 + !byte $41,%01101100 + !byte $41,%01001100 + !byte $43,%00101100 + !byte $43,%00001100 + !byte $45,%10101011 + !byte $47,%01101011 + !byte $49,%00101011 + !byte $49,%00001011 + !byte $4B,%10101010 + !byte $4D,%01101010 + !byte $4D,%01001010 + !byte $4F,%00001010 + !byte $4F,%11001001 + !byte $51,%10001001 + !byte $51,%01101001 + !byte $53,%00001001 + !byte $55,%10001000 + !byte $55,%01101000 + !byte $57,%00001000 + !byte $57,%11000111 + !byte $59,%01100111 + !byte $59,%01000111 + !byte $5B,%10100110 + !byte $5B,%10000110 + !byte $5D,%00000110 + !byte $5D,%11000101 + !byte $5D,%10100101 + !byte $5F,%00000101 + !byte $5F,%11000100 + !byte $5F,%10100100 + !byte $01,%01110000 + !byte $03,%01110000 + !byte $05,%01110000 + !byte $07,%01110000 + !byte $09,%01110000 + !byte $0B,%01110000 + !byte $0D,%01010000 + !byte $0F,%01010000 + !byte $11,%01010000 + !byte $13,%00110000 + !byte $15,%00110000 + !byte $17,%00010000 + !byte $19,%00010000 + !byte $1B,%11001111 + !byte $1D,%11001111 + !byte $1D,%10101111 + !byte $1F,%10101111 + !byte $21,%10001111 + !byte $23,%01101111 + !byte $25,%01001111 + !byte $27,%00101111 + !byte $29,%00001111 + !byte $2B,%11001110 + !byte $2D,%10101110 + !byte $2F,%10001110 + !byte $31,%01101110 + !byte $33,%00101110 + !byte $35,%00001110 + !byte $37,%10101101 + !byte $39,%10001101 + !byte $3B,%01001101 + !byte $3D,%00101101 + !byte $3D,%00001101 + !byte $3F,%11001100 + !byte $41,%10001100 + !byte $43,%01001100 + !byte $45,%00001100 + !byte $45,%11001011 + !byte $47,%10101011 + !byte $47,%10001011 + !byte $49,%01001011 + !byte $4B,%00001011 + !byte $4B,%11001010 + !byte $4D,%10001010 + !byte $4F,%00101010 + !byte $51,%10101001 + !byte $53,%01001001 + !byte $53,%00101001 + !byte $55,%11001000 + !byte $55,%10101000 + !byte $57,%01001000 + !byte $57,%00101000 + !byte $59,%10100111 + !byte $59,%10000111 + !byte $5B,%00000111 + !byte $5B,%11000110 + !byte $5D,%01000110 + !byte $5D,%00100110 + !byte $5F,%10000101 + !byte $5F,%01100101 + !byte $5F,%01000101 + !byte $5F,%00100101 + !byte $01,%10010000 + !byte $03,%10010000 + !byte $05,%10010000 + !byte $07,%10010000 + !byte $09,%10010000 + !byte $0B,%10010000 + !byte $0D,%01110000 + !byte $0F,%01110000 + !byte $11,%01110000 + !byte $13,%01010000 + !byte $15,%01010000 + !byte $17,%00110000 + !byte $19,%00110000 + !byte $1B,%00010000 + !byte $1D,%00010000 + !byte $1F,%11001111 + !byte $21,%10101111 + !byte $23,%10001111 + !byte $25,%01101111 + !byte $27,%01001111 + !byte $29,%00101111 + !byte $2B,%00001111 + !byte $2D,%11001110 + !byte $2F,%10101110 + !byte $31,%10001110 + !byte $33,%01101110 + !byte $33,%01001110 + !byte $35,%00101110 + !byte $37,%00001110 + !byte $37,%11001101 + !byte $39,%10101101 + !byte $3B,%10001101 + !byte $3B,%01101101 + !byte $3D,%01001101 + !byte $3F,%00001101 + !byte $41,%10101100 + !byte $43,%01101100 + !byte $45,%00101100 + !byte $47,%11001011 + !byte $49,%10001011 + !byte $49,%01101011 + !byte $4B,%00101011 + !byte $4D,%11001010 + !byte $4D,%10101010 + !byte $4F,%01101010 + !byte $4F,%01001010 + !byte $51,%00001010 + !byte $51,%11001001 + !byte $53,%10001001 + !byte $53,%01101001 + !byte $55,%00101001 + !byte $55,%00001001 + !byte $57,%10001000 + !byte $57,%01101000 + !byte $59,%00001000 + !byte $59,%11000111 + !byte $5B,%01100111 + !byte $5B,%01000111 + !byte $5B,%00100111 + !byte $5D,%10100110 + !byte $5D,%10000110 + !byte $5D,%01100110 + !byte $5F,%11000101 + !byte $5F,%10100101 + !byte $01,%10110000 + !byte $03,%10110000 + !byte $05,%10110000 + !byte $07,%10110000 + !byte $09,%10110000 + !byte $0B,%10110000 + !byte $0D,%10010000 + !byte $0F,%10010000 + !byte $11,%10010000 + !byte $13,%01110000 + !byte $15,%01110000 + !byte $17,%01010000 + !byte $19,%01010000 + !byte $1B,%00110000 + !byte $1D,%00110000 + !byte $1F,%00010000 + !byte $21,%11001111 + !byte $23,%10101111 + !byte $25,%10001111 + !byte $27,%01101111 + !byte $29,%01101111 + !byte $29,%01001111 + !byte $2B,%00101111 + !byte $2D,%00001111 + !byte $2F,%11001110 + !byte $31,%10101110 + !byte $33,%10001110 + !byte $35,%01001110 + !byte $37,%00101110 + !byte $39,%11001101 + !byte $3B,%10101101 + !byte $3D,%01101101 + !byte $3F,%00101101 + !byte $41,%11001100 + !byte $43,%10101100 + !byte $43,%10001100 + !byte $45,%01101100 + !byte $45,%01001100 + !byte $47,%00001100 + !byte $49,%10101011 + !byte $4B,%01101011 + !byte $4B,%01001011 + !byte $4D,%00001011 + !byte $4F,%10101010 + !byte $4F,%10001010 + !byte $51,%01001010 + !byte $51,%00101010 + !byte $53,%11001001 + !byte $53,%10101001 + !byte $55,%01001001 + !byte $57,%11001000 + !byte $57,%10101000 + !byte $59,%01001000 + !byte $59,%00101000 + !byte $5B,%10100111 + !byte $5B,%10000111 + !byte $5D,%00000111 + !byte $5D,%11000110 + !byte $5F,%01000110 + !byte $5F,%00100110 + !byte $5F,%00000110 + !byte $01,%11010000 + !byte $03,%11010000 + !byte $05,%11010000 + !byte $07,%11010000 + !byte $09,%11010000 + !byte $0B,%11010000 + !byte $0D,%10110000 + !byte $0F,%10110000 + !byte $11,%10110000 + !byte $13,%10010000 + !byte $15,%10010000 + !byte $17,%01110000 + !byte $19,%01110000 + !byte $1B,%01010000 + !byte $1D,%01010000 + !byte $1F,%00110000 + !byte $21,%00010000 + !byte $23,%11001111 + !byte $25,%10101111 + !byte $27,%10101111 + !byte $27,%10001111 + !byte $29,%10001111 + !byte $2B,%01101111 + !byte $2B,%01001111 + !byte $2D,%00101111 + !byte $2F,%00001111 + !byte $31,%11001110 + !byte $33,%10101110 + !byte $35,%01101110 + !byte $37,%01001110 + !byte $39,%00101110 + !byte $39,%00001110 + !byte $3B,%11001101 + !byte $3D,%10001101 + !byte $3F,%01101101 + !byte $3F,%01001101 + !byte $41,%00101101 + !byte $41,%00001101 + !byte $43,%11001100 + !byte $45,%10001100 + !byte $47,%01001100 + !byte $47,%00101100 + !byte $49,%00001100 + !byte $49,%11001011 + !byte $4B,%10001011 + !byte $4D,%01001011 + !byte $4D,%00101011 + !byte $4F,%11001010 + !byte $51,%01101010 + !byte $53,%00001010 + !byte $55,%10001001 + !byte $55,%01101001 + !byte $57,%00101001 + !byte $57,%00001001 + !byte $59,%10001000 + !byte $59,%01101000 + !byte $5B,%00001000 + !byte $5B,%11000111 + !byte $5D,%01000111 + !byte $5D,%00100111 + !byte $5F,%10100110 + !byte $5F,%10000110 + !byte $5F,%01100110 + !byte $01,%00010001 + !byte $03,%00010001 + !byte $05,%00010001 + !byte $07,%00010001 + !byte $09,%00010001 + !byte $0B,%00010001 + !byte $0D,%11010000 + !byte $0F,%11010000 + !byte $11,%11010000 + !byte $13,%10110000 + !byte $15,%10110000 + !byte $17,%10010000 + !byte $19,%10010000 + !byte $1B,%01110000 + !byte $1D,%01110000 + !byte $1F,%01010000 + !byte $21,%00110000 + !byte $23,%00010000 + !byte $25,%00010000 + !byte $25,%11001111 + !byte $27,%11001111 + !byte $29,%10101111 + !byte $2B,%10001111 + !byte $2D,%01101111 + !byte $2D,%01001111 + !byte $2F,%00101111 + !byte $31,%00001111 + !byte $33,%11001110 + !byte $35,%10101110 + !byte $35,%10001110 + !byte $37,%01101110 + !byte $39,%01001110 + !byte $3B,%00001110 + !byte $3D,%11001101 + !byte $3D,%10101101 + !byte $3F,%10001101 + !byte $41,%01001101 + !byte $43,%00001101 + !byte $45,%10101100 + !byte $47,%01101100 + !byte $49,%00101100 + !byte $4B,%11001011 + !byte $4B,%10101011 + !byte $4D,%01101011 + !byte $4F,%00101011 + !byte $4F,%00001011 + !byte $51,%10101010 + !byte $51,%10001010 + !byte $53,%01001010 + !byte $53,%00101010 + !byte $55,%11001001 + !byte $55,%10101001 + !byte $57,%01101001 + !byte $57,%01001001 + !byte $59,%11001000 + !byte $59,%10101000 + !byte $5B,%01001000 + !byte $5B,%00101000 + !byte $5D,%10100111 + !byte $5D,%10000111 + !byte $5D,%01100111 + !byte $5F,%00000111 + !byte $5F,%11000110 + !byte $01,%00110001 + !byte $03,%00110001 + !byte $05,%00110001 + !byte $07,%00110001 + !byte $09,%00110001 + !byte $0B,%00110001 + !byte $0D,%00010001 + !byte $0F,%00010001 + !byte $11,%00010001 + !byte $13,%11010000 + !byte $15,%11010000 + !byte $17,%10110000 + !byte $19,%10110000 + !byte $1B,%10010000 + !byte $1D,%10010000 + !byte $1F,%01110000 + !byte $21,%01010000 + !byte $23,%00110000 + !byte $25,%00110000 + !byte $27,%00010000 + !byte $29,%11001111 + !byte $2B,%10101111 + !byte $2D,%10001111 + !byte $2F,%01101111 + !byte $2F,%01001111 + !byte $31,%00101111 + !byte $33,%00001111 + !byte $35,%11001110 + !byte $37,%10001110 + !byte $39,%01101110 + !byte $3B,%00101110 + !byte $3D,%00001110 + !byte $3F,%10101101 + !byte $41,%01101101 + !byte $43,%00101101 + !byte $45,%00001101 + !byte $45,%11001100 + !byte $47,%10101100 + !byte $47,%10001100 + !byte $49,%01001100 + !byte $4B,%00001100 + !byte $4D,%10101011 + !byte $4D,%10001011 + !byte $4F,%01001011 + !byte $51,%00001011 + !byte $51,%11001010 + !byte $53,%10001010 + !byte $53,%01101010 + !byte $55,%00101010 + !byte $55,%00001010 + !byte $57,%10001001 + !byte $59,%00101001 + !byte $59,%00001001 + !byte $5B,%10001000 + !byte $5B,%01101000 + !byte $5D,%00001000 + !byte $5D,%11000111 + !byte $5F,%01000111 + !byte $5F,%00100111 + !byte $01,%01010001 + !byte $03,%01010001 + !byte $05,%01010001 + !byte $07,%01010001 + !byte $09,%01010001 + !byte $0B,%01010001 + !byte $0D,%00110001 + !byte $0F,%00110001 + !byte $11,%00110001 + !byte $13,%00010001 + !byte $15,%00010001 + !byte $17,%11010000 + !byte $19,%11010000 + !byte $1B,%10110000 + !byte $1D,%10110000 + !byte $1F,%10010000 + !byte $21,%01110000 + !byte $23,%01110000 + !byte $23,%01010000 + !byte $25,%01010000 + !byte $27,%00110000 + !byte $29,%00010000 + !byte $2B,%11001111 + !byte $2D,%10101111 + !byte $2F,%10001111 + !byte $31,%01101111 + !byte $31,%01001111 + !byte $33,%00101111 + !byte $35,%00001111 + !byte $37,%11001110 + !byte $37,%10101110 + !byte $39,%10001110 + !byte $3B,%01101110 + !byte $3B,%01001110 + !byte $3D,%00101110 + !byte $3F,%11001101 + !byte $41,%10101101 + !byte $41,%10001101 + !byte $43,%01101101 + !byte $43,%01001101 + !byte $45,%00101101 + !byte $47,%11001100 + !byte $49,%10001100 + !byte $49,%01101100 + !byte $4B,%00101100 + !byte $4D,%11001011 + !byte $4F,%10001011 + !byte $4F,%01101011 + !byte $51,%00101011 + !byte $53,%10101010 + !byte $55,%01001010 + !byte $57,%11001001 + !byte $57,%10101001 + !byte $59,%01101001 + !byte $59,%01001001 + !byte $5B,%11001000 + !byte $5B,%10101000 + !byte $5D,%01001000 + !byte $5D,%00101000 + !byte $5F,%10100111 + !byte $5F,%10000111 + !byte $5F,%01100111 + !byte $01,%01110001 + !byte $03,%01110001 + !byte $05,%01110001 + !byte $07,%01110001 + !byte $09,%01110001 + !byte $0B,%01110001 + !byte $0D,%01110001 + !byte $0D,%01010001 + !byte $0F,%01010001 + !byte $11,%01010001 + !byte $13,%00110001 + !byte $15,%00110001 + !byte $17,%00010001 + !byte $19,%00010001 + !byte $1B,%11010000 + !byte $1D,%11010000 + !byte $1F,%10110000 + !byte $21,%10010000 + !byte $23,%10010000 + !byte $25,%01110000 + !byte $27,%01010000 + !byte $29,%00110000 + !byte $2B,%00010000 + !byte $2D,%11001111 + !byte $2F,%10101111 + !byte $31,%10001111 + !byte $33,%01001111 + !byte $35,%00101111 + !byte $37,%00001111 + !byte $39,%10101110 + !byte $3B,%10001110 + !byte $3D,%01001110 + !byte $3F,%00101110 + !byte $3F,%00001110 + !byte $41,%11001101 + !byte $43,%10001101 + !byte $45,%01001101 + !byte $47,%00001101 + !byte $49,%10101100 + !byte $4B,%01101100 + !byte $4B,%01001100 + !byte $4D,%00101100 + !byte $4D,%00001100 + !byte $4F,%10101011 + !byte $51,%01101011 + !byte $51,%01001011 + !byte $53,%00001011 + !byte $53,%11001010 + !byte $55,%10001010 + !byte $55,%01101010 + !byte $57,%00101010 + !byte $57,%00001010 + !byte $59,%10001001 + !byte $5B,%00101001 + !byte $5B,%00001001 + !byte $5D,%10001000 + !byte $5D,%01101000 + !byte $5F,%00001000 + !byte $5F,%11000111 + !byte $01,%10010001 + !byte $03,%10010001 + !byte $05,%10010001 + !byte $07,%10010001 + !byte $09,%10010001 + !byte $0B,%10010001 + !byte $0D,%10010001 + !byte $0F,%01110001 + !byte $11,%01110001 + !byte $13,%01010001 + !byte $15,%01010001 + !byte $17,%01010001 + !byte $17,%00110001 + !byte $19,%00110001 + !byte $1B,%00010001 + !byte $1D,%00010001 + !byte $1F,%11010000 + !byte $21,%10110000 + !byte $23,%10110000 + !byte $25,%10010000 + !byte $27,%01110000 + !byte $29,%01010000 + !byte $2B,%00110000 + !byte $2D,%00010000 + !byte $2F,%11001111 + !byte $31,%10101111 + !byte $33,%10001111 + !byte $33,%01101111 + !byte $35,%01001111 + !byte $37,%00101111 + !byte $39,%11001110 + !byte $3B,%10101110 + !byte $3D,%10001110 + !byte $3D,%01101110 + !byte $3F,%01001110 + !byte $41,%00001110 + !byte $43,%11001101 + !byte $43,%10101101 + !byte $45,%10001101 + !byte $45,%01101101 + !byte $47,%00101101 + !byte $49,%00001101 + !byte $49,%11001100 + !byte $4B,%10001100 + !byte $4D,%01001100 + !byte $4F,%00001100 + !byte $4F,%11001011 + !byte $51,%10001011 + !byte $53,%01001011 + !byte $53,%00101011 + !byte $55,%11001010 + !byte $55,%10101010 + !byte $57,%01101010 + !byte $57,%01001010 + !byte $59,%11001001 + !byte $59,%10101001 + !byte $5B,%01101001 + !byte $5B,%01001001 + !byte $5D,%11001000 + !byte $5D,%10101000 + !byte $5F,%01001000 + !byte $5F,%00101000 + !byte $01,%10110001 + !byte $03,%10110001 + !byte $05,%10110001 + !byte $07,%10110001 + !byte $09,%10110001 + !byte $0B,%10110001 + !byte $0D,%10110001 + !byte $0F,%10010001 + !byte $11,%10010001 + !byte $13,%01110001 + !byte $15,%01110001 + !byte $17,%01110001 + !byte $19,%01010001 + !byte $1B,%00110001 + !byte $1D,%00110001 + !byte $1F,%00010001 + !byte $21,%11010000 + !byte $23,%11010000 + !byte $25,%10110000 + !byte $27,%10010000 + !byte $29,%01110000 + !byte $2B,%01010000 + !byte $2D,%00110000 + !byte $2F,%00010000 + !byte $31,%11001111 + !byte $33,%10101111 + !byte $35,%01101111 + !byte $37,%01001111 + !byte $39,%00101111 + !byte $39,%00001111 + !byte $3B,%11001110 + !byte $3D,%10101110 + !byte $3F,%01101110 + !byte $41,%00101110 + !byte $43,%00001110 + !byte $45,%10101101 + !byte $47,%01101101 + !byte $47,%01001101 + !byte $49,%00101101 + !byte $4B,%11001100 + !byte $4B,%10101100 + !byte $4D,%01101100 + !byte $4F,%00101100 + !byte $51,%11001011 + !byte $51,%10101011 + !byte $53,%01101011 + !byte $55,%00001011 + !byte $57,%10001010 + !byte $59,%00101010 + !byte $59,%00001010 + !byte $5B,%10101001 + !byte $5B,%10001001 + !byte $5D,%00101001 + !byte $5D,%00001001 + !byte $5F,%10001000 + !byte $5F,%01101000 + !byte $01,%11010001 + !byte $03,%11010001 + !byte $05,%11010001 + !byte $07,%11010001 + !byte $09,%11010001 + !byte $0B,%11010001 + !byte $0D,%11010001 + !byte $0F,%10110001 + !byte $11,%10110001 + !byte $13,%10010001 + !byte $15,%10010001 + !byte $17,%10010001 + !byte $19,%01110001 + !byte $1B,%01010001 + !byte $1D,%01010001 + !byte $1F,%00110001 + !byte $21,%00010001 + !byte $23,%00010001 + !byte $25,%11010000 + !byte $27,%10110000 + !byte $29,%10010000 + !byte $2B,%01110000 + !byte $2D,%01010000 + !byte $2F,%00110000 + !byte $31,%00010000 + !byte $33,%11001111 + !byte $35,%10101111 + !byte $35,%10001111 + !byte $37,%01101111 + !byte $39,%01001111 + !byte $3B,%00001111 + !byte $3D,%11001110 + !byte $3F,%10001110 + !byte $41,%01101110 + !byte $41,%01001110 + !byte $43,%00101110 + !byte $45,%11001101 + !byte $47,%10001101 + !byte $49,%01001101 + !byte $4B,%00001101 + !byte $4D,%10101100 + !byte $4D,%10001100 + !byte $4F,%01001100 + !byte $51,%00001100 + !byte $53,%10001011 + !byte $55,%01001011 + !byte $55,%00101011 + !byte $57,%11001010 + !byte $57,%10101010 + !byte $59,%01101010 + !byte $59,%01001010 + !byte $5B,%11001001 + !byte $5D,%01101001 + !byte $5D,%01001001 + !byte $5F,%11001000 + !byte $5F,%10101000 + !byte $01,%00010010 + !byte $03,%00010010 + !byte $05,%00010010 + !byte $07,%00010010 + !byte $09,%00010010 + !byte $0B,%00010010 + !byte $0D,%00010010 + !byte $0F,%11010001 + !byte $11,%11010001 + !byte $13,%10110001 + !byte $15,%10110001 + !byte $17,%10110001 + !byte $19,%10010001 + !byte $1B,%01110001 + !byte $1D,%01110001 + !byte $1F,%01010001 + !byte $21,%01010001 + !byte $21,%00110001 + !byte $23,%00110001 + !byte $25,%00010001 + !byte $27,%11010000 + !byte $29,%10110000 + !byte $2B,%10010000 + !byte $2D,%01110000 + !byte $2F,%01010000 + !byte $31,%00110000 + !byte $33,%00010000 + !byte $35,%11001111 + !byte $37,%10001111 + !byte $39,%01101111 + !byte $3B,%01001111 + !byte $3B,%00101111 + !byte $3D,%00001111 + !byte $3F,%11001110 + !byte $3F,%10101110 + !byte $41,%10001110 + !byte $43,%01001110 + !byte $45,%00001110 + !byte $47,%11001101 + !byte $47,%10101101 + !byte $49,%01101101 + !byte $4B,%00101101 + !byte $4D,%11001100 + !byte $4F,%10001100 + !byte $4F,%01101100 + !byte $51,%00101100 + !byte $53,%11001011 + !byte $53,%10101011 + !byte $55,%01101011 + !byte $57,%00101011 + !byte $57,%00001011 + !byte $59,%10001010 + !byte $5B,%00101010 + !byte $5B,%00001010 + !byte $5D,%10101001 + !byte $5D,%10001001 + !byte $5F,%00101001 + !byte $5F,%00001001 + !byte $01,%00110010 + !byte $03,%00110010 + !byte $05,%00110010 + !byte $07,%00110010 + !byte $09,%00110010 + !byte $0B,%00110010 + !byte $0D,%00110010 + !byte $0F,%00010010 + !byte $11,%00010010 + !byte $13,%00010010 + !byte $13,%11010001 + !byte $15,%11010001 + !byte $17,%11010001 + !byte $19,%10110001 + !byte $1B,%10110001 + !byte $1B,%10010001 + !byte $1D,%10010001 + !byte $1F,%01110001 + !byte $21,%01110001 + !byte $23,%01010001 + !byte $25,%00110001 + !byte $27,%00010001 + !byte $29,%11010000 + !byte $2B,%10110000 + !byte $2D,%10010000 + !byte $2F,%01110000 + !byte $31,%01010000 + !byte $33,%00110000 + !byte $35,%00010000 + !byte $37,%11001111 + !byte $37,%10101111 + !byte $39,%10001111 + !byte $3B,%01101111 + !byte $3D,%00101111 + !byte $3F,%00001111 + !byte $41,%10101110 + !byte $43,%01101110 + !byte $45,%01001110 + !byte $45,%00101110 + !byte $47,%00001110 + !byte $49,%10101101 + !byte $49,%10001101 + !byte $4B,%01101101 + !byte $4B,%01001101 + !byte $4D,%00101101 + !byte $4D,%00001101 + !byte $4F,%10101100 + !byte $51,%01101100 + !byte $51,%01001100 + !byte $53,%00001100 + !byte $55,%10101011 + !byte $55,%10001011 + !byte $57,%01001011 + !byte $59,%11001010 + !byte $59,%10101010 + !byte $5B,%01101010 + !byte $5B,%01001010 + !byte $5D,%00001010 + !byte $5D,%11001001 + !byte $5F,%01101001 + !byte $5F,%01001001 + !byte $01,%01010010 + !byte $03,%01010010 + !byte $05,%01010010 + !byte $07,%01010010 + !byte $09,%01010010 + !byte $0B,%01010010 + !byte $0D,%01010010 + !byte $0F,%00110010 + !byte $11,%00110010 + !byte $13,%00110010 + !byte $15,%00010010 + !byte $17,%00010010 + !byte $19,%11010001 + !byte $1B,%11010001 + !byte $1D,%10110001 + !byte $1F,%10010001 + !byte $21,%10010001 + !byte $23,%01110001 + !byte $25,%01010001 + !byte $27,%00110001 + !byte $29,%00010001 + !byte $2B,%00010001 + !byte $2B,%11010000 + !byte $2D,%11010000 + !byte $2D,%10110000 + !byte $2F,%10010000 + !byte $31,%01110000 + !byte $33,%01010000 + !byte $35,%00110000 + !byte $37,%00010000 + !byte $39,%10101111 + !byte $3B,%10001111 + !byte $3D,%01101111 + !byte $3D,%01001111 + !byte $3F,%00101111 + !byte $41,%11001110 + !byte $43,%10101110 + !byte $43,%10001110 + !byte $45,%01101110 + !byte $47,%00101110 + !byte $49,%11001101 + !byte $4B,%10001101 + !byte $4D,%01001101 + !byte $4F,%00001101 + !byte $4F,%11001100 + !byte $51,%10101100 + !byte $51,%10001100 + !byte $53,%01001100 + !byte $53,%00101100 + !byte $55,%11001011 + !byte $57,%10001011 + !byte $57,%01101011 + !byte $59,%00101011 + !byte $59,%00001011 + !byte $5B,%10101010 + !byte $5B,%10001010 + !byte $5D,%00101010 + !byte $5F,%10101001 + !byte $5F,%10001001 + !byte $01,%01110010 + !byte $03,%01110010 + !byte $05,%01110010 + !byte $07,%01110010 + !byte $09,%01110010 + !byte $0B,%01110010 + !byte $0D,%01110010 + !byte $0F,%01010010 + !byte $11,%01010010 + !byte $13,%01010010 + !byte $15,%00110010 + !byte $17,%00110010 + !byte $19,%00010010 + !byte $1B,%00010010 + !byte $1D,%11010001 + !byte $1F,%10110001 + !byte $21,%10110001 + !byte $23,%10010001 + !byte $25,%01110001 + !byte $27,%01010001 + !byte $29,%01010001 + !byte $29,%00110001 + !byte $2B,%00110001 + !byte $2D,%00010001 + !byte $2F,%11010000 + !byte $2F,%10110000 + !byte $31,%10110000 + !byte $31,%10010000 + !byte $33,%01110000 + !byte $35,%01010000 + !byte $37,%00110000 + !byte $39,%11001111 + !byte $3B,%10101111 + !byte $3D,%10001111 + !byte $3F,%01001111 + !byte $41,%00101111 + !byte $41,%00001111 + !byte $43,%11001110 + !byte $45,%10001110 + !byte $47,%01001110 + !byte $49,%00101110 + !byte $49,%00001110 + !byte $4B,%11001101 + !byte $4B,%10101101 + !byte $4D,%01101101 + !byte $4F,%00101101 + !byte $51,%11001100 + !byte $53,%01101100 + !byte $55,%00101100 + !byte $55,%00001100 + !byte $57,%10101011 + !byte $59,%01001011 + !byte $5B,%11001010 + !byte $5D,%01101010 + !byte $5D,%01001010 + !byte $5F,%00001010 + !byte $5F,%11001001 + !byte $01,%10010010 + !byte $03,%10010010 + !byte $05,%10010010 + !byte $07,%10010010 + !byte $09,%10010010 + !byte $0B,%10010010 + !byte $0D,%10010010 + !byte $0F,%01110010 + !byte $11,%01110010 + !byte $13,%01110010 + !byte $15,%01010010 + !byte $17,%01010010 + !byte $19,%00110010 + !byte $1B,%00110010 + !byte $1D,%00010010 + !byte $1F,%11010001 + !byte $21,%11010001 + !byte $23,%10110001 + !byte $25,%10010001 + !byte $27,%01110001 + !byte $29,%01110001 + !byte $2B,%01010001 + !byte $2D,%00110001 + !byte $2F,%00010001 + !byte $31,%11010000 + !byte $33,%10010000 + !byte $35,%01110000 + !byte $37,%01010000 + !byte $39,%00110000 + !byte $39,%00010000 + !byte $3B,%11001111 + !byte $3D,%10101111 + !byte $3F,%01101111 + !byte $41,%01001111 + !byte $43,%00001111 + !byte $45,%11001110 + !byte $45,%10101110 + !byte $47,%10001110 + !byte $47,%01101110 + !byte $49,%01001110 + !byte $4B,%00001110 + !byte $4D,%10101101 + !byte $4D,%10001101 + !byte $4F,%01101101 + !byte $4F,%01001101 + !byte $51,%00001101 + !byte $53,%10101100 + !byte $53,%10001100 + !byte $55,%01001100 + !byte $57,%00001100 + !byte $57,%11001011 + !byte $59,%10001011 + !byte $59,%01101011 + !byte $5B,%00101011 + !byte $5B,%00001011 + !byte $5D,%10101010 + !byte $5D,%10001010 + !byte $5F,%01001010 + !byte $5F,%00101010 + !byte $01,%10110010 + !byte $03,%10110010 + !byte $05,%10110010 + !byte $07,%10110010 + !byte $09,%10110010 + !byte $0B,%10110010 + !byte $0D,%10110010 + !byte $0F,%10010010 + !byte $11,%10010010 + !byte $13,%10010010 + !byte $15,%01110010 + !byte $17,%01110010 + !byte $19,%01010010 + !byte $1B,%01010010 + !byte $1D,%00110010 + !byte $1F,%00010010 + !byte $21,%00010010 + !byte $23,%11010001 + !byte $25,%10110001 + !byte $27,%10110001 + !byte $27,%10010001 + !byte $29,%10010001 + !byte $2B,%01110001 + !byte $2D,%01010001 + !byte $2F,%00110001 + !byte $31,%00010001 + !byte $33,%11010000 + !byte $33,%10110000 + !byte $35,%10010000 + !byte $37,%01110000 + !byte $39,%01010000 + !byte $3B,%00010000 + !byte $3D,%11001111 + !byte $3F,%10101111 + !byte $3F,%10001111 + !byte $41,%01101111 + !byte $43,%00101111 + !byte $45,%00001111 + !byte $47,%10101110 + !byte $49,%01101110 + !byte $4B,%00101110 + !byte $4D,%11001101 + !byte $4F,%10001101 + !byte $51,%01001101 + !byte $51,%00101101 + !byte $53,%00001101 + !byte $53,%11001100 + !byte $55,%10001100 + !byte $55,%01101100 + !byte $57,%00101100 + !byte $59,%11001011 + !byte $59,%10101011 + !byte $5B,%01101011 + !byte $5B,%01001011 + !byte $5D,%00001011 + !byte $5D,%11001010 + !byte $5F,%01101010 + !byte $01,%11010010 + !byte $03,%11010010 + !byte $05,%11010010 + !byte $07,%11010010 + !byte $09,%11010010 + !byte $0B,%11010010 + !byte $0D,%11010010 + !byte $0F,%10110010 + !byte $11,%10110010 + !byte $13,%10110010 + !byte $15,%10010010 + !byte $17,%10010010 + !byte $19,%01110010 + !byte $1B,%01110010 + !byte $1D,%01010010 + !byte $1F,%00110010 + !byte $21,%00110010 + !byte $23,%00010010 + !byte $25,%11010001 + !byte $27,%11010001 + !byte $29,%10110001 + !byte $2B,%10010001 + !byte $2D,%01110001 + !byte $2F,%01010001 + !byte $31,%00110001 + !byte $33,%00010001 + !byte $35,%11010000 + !byte $35,%10110000 + !byte $37,%10010000 + !byte $39,%01110000 + !byte $3B,%01010000 + !byte $3B,%00110000 + !byte $3D,%00010000 + !byte $3F,%11001111 + !byte $41,%10001111 + !byte $43,%01101111 + !byte $43,%01001111 + !byte $45,%00101111 + !byte $47,%11001110 + !byte $49,%10001110 + !byte $4B,%01001110 + !byte $4D,%00101110 + !byte $4D,%00001110 + !byte $4F,%10101101 + !byte $51,%01101101 + !byte $53,%00101101 + !byte $55,%11001100 + !byte $55,%10101100 + !byte $57,%01101100 + !byte $57,%01001100 + !byte $59,%00001100 + !byte $5B,%10001011 + !byte $5D,%00101011 + !byte $5F,%10101010 + !byte $5F,%10001010 + !byte $01,%00010011 + !byte $03,%00010011 + !byte $05,%00010011 + !byte $07,%00010011 + !byte $09,%00010011 + !byte $0B,%00010011 + !byte $0D,%00010011 + !byte $0F,%11010010 + !byte $11,%11010010 + !byte $13,%11010010 + !byte $15,%10110010 + !byte $17,%10110010 + !byte $19,%10010010 + !byte $1B,%10010010 + !byte $1D,%01110010 + !byte $1F,%01110010 + !byte $1F,%01010010 + !byte $21,%01010010 + !byte $23,%00110010 + !byte $25,%00010010 + !byte $27,%00010010 + !byte $29,%11010001 + !byte $2B,%10110001 + !byte $2D,%10010001 + !byte $2F,%01110001 + !byte $31,%01010001 + !byte $33,%00110001 + !byte $35,%00010001 + !byte $37,%10110000 + !byte $39,%10010000 + !byte $3B,%01110000 + !byte $3D,%00110000 + !byte $3F,%00010000 + !byte $41,%11001111 + !byte $41,%10101111 + !byte $43,%10001111 + !byte $45,%01001111 + !byte $47,%00101111 + !byte $47,%00001111 + !byte $49,%11001110 + !byte $49,%10101110 + !byte $4B,%10001110 + !byte $4B,%01101110 + !byte $4D,%01001110 + !byte $4F,%00001110 + !byte $4F,%11001101 + !byte $51,%10001101 + !byte $53,%01001101 + !byte $55,%00001101 + !byte $57,%10001100 + !byte $59,%01001100 + !byte $59,%00101100 + !byte $5B,%11001011 + !byte $5B,%10101011 + !byte $5D,%01101011 + !byte $5D,%01001011 + !byte $5F,%00001011 + !byte $5F,%11001010 + !byte $01,%00110011 + !byte $03,%00110011 + !byte $05,%00110011 + !byte $07,%00110011 + !byte $09,%00110011 + !byte $0B,%00110011 + !byte $0D,%00110011 + !byte $0F,%00010011 + !byte $11,%00010011 + !byte $13,%00010011 + !byte $15,%11010010 + !byte $17,%11010010 + !byte $19,%10110010 + !byte $1B,%10110010 + !byte $1D,%10010010 + !byte $1F,%10010010 + !byte $21,%01110010 + !byte $23,%01010010 + !byte $25,%00110010 + !byte $27,%00110010 + !byte $29,%00010010 + !byte $2B,%11010001 + !byte $2D,%10110001 + !byte $2F,%10010001 + !byte $31,%01110001 + !byte $33,%01010001 + !byte $35,%00110001 + !byte $37,%00010001 + !byte $37,%11010000 + !byte $39,%10110000 + !byte $3B,%10010000 + !byte $3D,%01110000 + !byte $3D,%01010000 + !byte $3F,%00110000 + !byte $41,%00010000 + !byte $43,%10101111 + !byte $45,%01101111 + !byte $47,%01001111 + !byte $49,%00001111 + !byte $4B,%10101110 + !byte $4D,%01101110 + !byte $4F,%00101110 + !byte $51,%11001101 + !byte $51,%10101101 + !byte $53,%10001101 + !byte $53,%01101101 + !byte $55,%00101101 + !byte $57,%11001100 + !byte $57,%10101100 + !byte $59,%01101100 + !byte $5B,%00101100 + !byte $5B,%00001100 + !byte $5D,%10101011 + !byte $5D,%10001011 + !byte $5F,%01001011 + !byte $5F,%00101011 + !byte $01,%01010011 + !byte $03,%01010011 + !byte $05,%01010011 + !byte $07,%01010011 + !byte $09,%01010011 + !byte $0B,%01010011 + !byte $0D,%01010011 + !byte $0F,%00110011 + !byte $11,%00110011 + !byte $13,%00110011 + !byte $15,%00010011 + !byte $17,%00010011 + !byte $19,%11010010 + !byte $1B,%11010010 + !byte $1D,%10110010 + !byte $1F,%10110010 + !byte $21,%10010010 + !byte $23,%01110010 + !byte $25,%01010010 + !byte $27,%01010010 + !byte $29,%00110010 + !byte $2B,%00010010 + !byte $2D,%11010001 + !byte $2F,%10110001 + !byte $31,%10010001 + !byte $33,%01110001 + !byte $35,%01010001 + !byte $37,%00110001 + !byte $39,%11010000 + !byte $3B,%10110000 + !byte $3D,%10010000 + !byte $3F,%01010000 + !byte $41,%00110000 + !byte $43,%11001111 + !byte $45,%10101111 + !byte $45,%10001111 + !byte $47,%01101111 + !byte $49,%00101111 + !byte $4B,%11001110 + !byte $4D,%10001110 + !byte $4F,%01101110 + !byte $4F,%01001110 + !byte $51,%00001110 + !byte $53,%10101101 + !byte $55,%01101101 + !byte $55,%01001101 + !byte $57,%00001101 + !byte $59,%10101100 + !byte $59,%10001100 + !byte $5B,%01001100 + !byte $5D,%11001011 + !byte $5F,%01101011 + !byte $01,%01110011 + !byte $03,%01110011 + !byte $05,%01110011 + !byte $07,%01110011 + !byte $09,%01110011 + !byte $0B,%01110011 + !byte $0D,%01110011 + !byte $0F,%01010011 + !byte $11,%01010011 + !byte $13,%01010011 + !byte $15,%00110011 + !byte $17,%00110011 + !byte $19,%00010011 + !byte $1B,%00010011 + !byte $1D,%11010010 + !byte $1F,%11010010 + !byte $21,%10110010 + !byte $23,%10010010 + !byte $25,%10010010 + !byte $25,%01110010 + !byte $27,%01110010 + !byte $29,%01010010 + !byte $2B,%00110010 + !byte $2D,%00010010 + !byte $2F,%11010001 + !byte $31,%10110001 + !byte $33,%10010001 + !byte $35,%01110001 + !byte $37,%01010001 + !byte $39,%00110001 + !byte $39,%00010001 + !byte $3B,%11010000 + !byte $3D,%10110000 + !byte $3F,%10010000 + !byte $3F,%01110000 + !byte $41,%01010000 + !byte $43,%00110000 + !byte $43,%00010000 + !byte $45,%11001111 + !byte $47,%10001111 + !byte $49,%01101111 + !byte $49,%01001111 + !byte $4B,%00101111 + !byte $4B,%00001111 + !byte $4D,%11001110 + !byte $4D,%10101110 + !byte $4F,%10001110 + !byte $51,%01001110 + !byte $51,%00101110 + !byte $53,%00001110 + !byte $53,%11001101 + !byte $55,%10001101 + !byte $57,%01001101 + !byte $57,%00101101 + !byte $59,%11001100 + !byte $5B,%10001100 + !byte $5B,%01101100 + !byte $5D,%00101100 + !byte $5D,%00001100 + !byte $5F,%10101011 + !byte $5F,%10001011 + !byte $01,%10010011 + !byte $03,%10010011 + !byte $05,%10010011 + !byte $07,%10010011 + !byte $09,%10010011 + !byte $0B,%10010011 + !byte $0D,%10010011 + !byte $0F,%01110011 + !byte $11,%01110011 + !byte $13,%01110011 + !byte $15,%01010011 + !byte $17,%01010011 + !byte $19,%00110011 + !byte $1B,%00110011 + !byte $1D,%00010011 + !byte $1F,%00010011 + !byte $21,%11010010 + !byte $23,%10110010 + !byte $25,%10110010 + !byte $27,%10010010 + !byte $29,%01110010 + !byte $2B,%01010010 + !byte $2D,%00110010 + !byte $2F,%00010010 + !byte $31,%11010001 + !byte $33,%10110001 + !byte $35,%10010001 + !byte $37,%01110001 + !byte $39,%01010001 + !byte $3B,%00010001 + !byte $3D,%11010000 + !byte $3F,%10110000 + !byte $41,%01110000 + !byte $43,%01010000 + !byte $45,%00010000 + !byte $47,%10101111 + !byte $49,%10001111 + !byte $4B,%01001111 + !byte $4D,%00001111 + !byte $4F,%10101110 + !byte $51,%01101110 + !byte $53,%00101110 + !byte $55,%11001101 + !byte $55,%10101101 + !byte $57,%01101101 + !byte $59,%00101101 + !byte $59,%00001101 + !byte $5B,%10101100 + !byte $5D,%01101100 + !byte $5D,%01001100 + !byte $5F,%00001100 + !byte $5F,%11001011 + !byte $01,%10110011 + !byte $03,%10110011 + !byte $05,%10110011 + !byte $07,%10110011 + !byte $09,%10110011 + !byte $0B,%10110011 + !byte $0D,%10110011 + !byte $0F,%10010011 + !byte $11,%10010011 + !byte $13,%10010011 + !byte $15,%01110011 + !byte $17,%01110011 + !byte $19,%01010011 + !byte $1B,%01010011 + !byte $1D,%00110011 + !byte $1F,%00110011 + !byte $21,%00010011 + !byte $23,%11010010 + !byte $25,%11010010 + !byte $27,%10110010 + !byte $29,%10010010 + !byte $2B,%01110010 + !byte $2D,%01010010 + !byte $2F,%00110010 + !byte $31,%00010010 + !byte $33,%11010001 + !byte $35,%10110001 + !byte $37,%10010001 + !byte $39,%01110001 + !byte $3B,%01010001 + !byte $3B,%00110001 + !byte $3D,%00010001 + !byte $3F,%11010000 + !byte $41,%10010000 + !byte $43,%01110000 + !byte $45,%00110000 + !byte $47,%00010000 + !byte $47,%11001111 + !byte $49,%10101111 + !byte $4B,%01101111 + !byte $4D,%00101111 + !byte $4F,%11001110 + !byte $51,%10001110 + !byte $53,%01001110 + !byte $55,%00001110 + !byte $57,%10101101 + !byte $57,%10001101 + !byte $59,%01001101 + !byte $5B,%00001101 + !byte $5B,%11001100 + !byte $5D,%10001100 + !byte $5F,%00101100 + !byte $01,%11010011 + !byte $03,%11010011 + !byte $05,%11010011 + !byte $07,%11010011 + !byte $09,%11010011 + !byte $0B,%11010011 + !byte $0D,%11010011 + !byte $0F,%10110011 + !byte $11,%10110011 + !byte $13,%10110011 + !byte $15,%10010011 + !byte $17,%10010011 + !byte $19,%01110011 + !byte $1B,%01110011 + !byte $1D,%01010011 + !byte $1F,%01010011 + !byte $21,%00110011 + !byte $23,%00010011 + !byte $25,%00010011 + !byte $27,%11010010 + !byte $29,%10110010 + !byte $2B,%10010010 + !byte $2D,%01110010 + !byte $2F,%01110010 + !byte $2F,%01010010 + !byte $31,%01010010 + !byte $31,%00110010 + !byte $33,%00010010 + !byte $35,%11010001 + !byte $37,%10110001 + !byte $39,%10010001 + !byte $3B,%01110001 + !byte $3D,%00110001 + !byte $3F,%00010001 + !byte $41,%11010000 + !byte $41,%10110000 + !byte $43,%10010000 + !byte $45,%01110000 + !byte $45,%01010000 + !byte $47,%00110000 + !byte $49,%11001111 + !byte $4B,%10001111 + !byte $4D,%01101111 + !byte $4D,%01001111 + !byte $4F,%00101111 + !byte $4F,%00001111 + !byte $51,%11001110 + !byte $51,%10101110 + !byte $53,%10001110 + !byte $53,%01101110 + !byte $55,%01001110 + !byte $55,%00101110 + !byte $57,%11001101 + !byte $59,%10001101 + !byte $59,%01101101 + !byte $5B,%00101101 + !byte $5D,%11001100 + !byte $5D,%10101100 + !byte $5F,%01101100 + !byte $5F,%01001100 + !byte $0F,%11010011 + !byte $11,%11010011 + !byte $13,%11010011 + !byte $15,%10110011 + !byte $17,%10110011 + !byte $19,%10010011 + !byte $1B,%10010011 + !byte $1D,%01110011 + !byte $1F,%01110011 + !byte $21,%01010011 + !byte $23,%00110011 + !byte $25,%00110011 + !byte $27,%00010011 + !byte $29,%11010010 + !byte $2B,%10110010 + !byte $2D,%10110010 + !byte $2D,%10010010 + !byte $2F,%10010010 + !byte $31,%01110010 + !byte $33,%01010010 + !byte $33,%00110010 + !byte $35,%00110010 + !byte $35,%00010010 + !byte $37,%11010001 + !byte $39,%10110001 + !byte $3B,%10010001 + !byte $3D,%01110001 + !byte $3D,%01010001 + !byte $3F,%00110001 + !byte $41,%00010001 + !byte $43,%10110000 + !byte $45,%10010000 + !byte $47,%01010000 + !byte $49,%00110000 + !byte $49,%00010000 + !byte $4B,%11001111 + !byte $4B,%10101111 + !byte $4D,%10001111 + !byte $4F,%01001111 + !byte $51,%00001111 + !byte $53,%10101110 + !byte $55,%01101110 + !byte $57,%00101110 + !byte $57,%00001110 + !byte $59,%10101101 + !byte $5B,%01101101 + !byte $5B,%01001101 + !byte $5D,%00001101 + !byte $5F,%10001100 + !byte $15,%11010011 + !byte $17,%11010011 + !byte $19,%10110011 + !byte $1B,%10110011 + !byte $1D,%10010011 + !byte $1F,%10010011 + !byte $21,%01110011 + !byte $23,%01110011 + !byte $23,%01010011 + !byte $25,%01010011 + !byte $27,%00110011 + !byte $29,%00010011 + !byte $2B,%11010010 + !byte $2D,%11010010 + !byte $2F,%10110010 + !byte $31,%10010010 + !byte $33,%01110010 + !byte $35,%01010010 + !byte $37,%00110010 + !byte $37,%00010010 + !byte $39,%11010001 + !byte $3B,%10110001 + !byte $3D,%10010001 + !byte $3F,%01010001 + !byte $41,%00110001 + !byte $43,%00010001 + !byte $43,%11010000 + !byte $45,%10110000 + !byte $47,%01110000 + !byte $49,%01010000 + !byte $4B,%00010000 + !byte $4D,%10101111 + !byte $4F,%01101111 + !byte $51,%00101111 + !byte $53,%11001110 + !byte $55,%10001110 + !byte $57,%01001110 + !byte $59,%00001110 + !byte $59,%11001101 + !byte $5B,%10001101 + !byte $5D,%01001101 + !byte $5D,%00101101 + !byte $5F,%11001100 + !byte $5F,%10101100 + !byte $19,%11010011 + !byte $1B,%11010011 + !byte $1D,%10110011 + !byte $1F,%10110011 + !byte $21,%10010011 + !byte $23,%10010011 + !byte $25,%01110011 + !byte $27,%01010011 + !byte $29,%00110011 + !byte $2B,%00010011 + !byte $2D,%00010011 + !byte $2F,%11010010 + !byte $31,%10110010 + !byte $33,%10010010 + !byte $35,%01110010 + !byte $37,%01010010 + !byte $39,%00010010 + !byte $3B,%11010001 + !byte $3D,%10110001 + !byte $3F,%10010001 + !byte $3F,%01110001 + !byte $41,%01010001 + !byte $43,%00110001 + !byte $45,%11010000 + !byte $47,%10110000 + !byte $47,%10010000 + !byte $49,%01110000 + !byte $4B,%00110000 + !byte $4D,%11001111 + !byte $4F,%10101111 + !byte $4F,%10001111 + !byte $51,%01101111 + !byte $51,%01001111 + !byte $53,%00101111 + !byte $53,%00001111 + !byte $55,%11001110 + !byte $55,%10101110 + !byte $57,%01101110 + !byte $59,%00101110 + !byte $5B,%11001101 + !byte $5B,%10101101 + !byte $5D,%01101101 + !byte $5F,%00001101 + !byte $1D,%11010011 + !byte $1F,%11010011 + !byte $21,%10110011 + !byte $23,%10110011 + !byte $25,%10010011 + !byte $27,%01110011 + !byte $29,%01010011 + !byte $2B,%01010011 + !byte $2B,%00110011 + !byte $2D,%00110011 + !byte $2F,%00010011 + !byte $31,%11010010 + !byte $33,%10110010 + !byte $35,%10010010 + !byte $37,%01110010 + !byte $39,%01010010 + !byte $39,%00110010 + !byte $3B,%00010010 + !byte $3D,%11010001 + !byte $3F,%10110001 + !byte $41,%01110001 + !byte $43,%01010001 + !byte $45,%00010001 + !byte $47,%11010000 + !byte $49,%10010000 + !byte $4B,%01110000 + !byte $4B,%01010000 + !byte $4D,%00110000 + !byte $4D,%00010000 + !byte $4F,%11001111 + !byte $51,%10001111 + !byte $53,%01001111 + !byte $55,%00001111 + !byte $57,%10101110 + !byte $57,%10001110 + !byte $59,%01101110 + !byte $59,%01001110 + !byte $5B,%00001110 + !byte $5D,%10101101 + !byte $5D,%10001101 + !byte $5F,%01001101 + !byte $5F,%00101101 + !byte $21,%11010011 + !byte $23,%11010011 + !byte $25,%10110011 + !byte $27,%10010011 + !byte $29,%01110011 + !byte $2B,%01110011 + !byte $2D,%01010011 + !byte $2F,%00110011 + !byte $31,%00010011 + !byte $33,%11010010 + !byte $35,%10110010 + !byte $37,%10010010 + !byte $39,%01110010 + !byte $3B,%00110010 + !byte $3D,%00010010 + !byte $3F,%11010001 + !byte $41,%10010001 + !byte $43,%01110001 + !byte $45,%01010001 + !byte $45,%00110001 + !byte $47,%00010001 + !byte $49,%10110000 + !byte $4B,%10010000 + !byte $4D,%01010000 + !byte $4F,%00010000 + !byte $51,%10101111 + !byte $53,%01101111 + !byte $55,%00101111 + !byte $57,%11001110 + !byte $59,%10001110 + !byte $5B,%01001110 + !byte $5B,%00101110 + !byte $5D,%11001101 + !byte $5F,%01101101 + !byte $25,%11010011 + !byte $27,%10110011 + !byte $29,%10010011 + !byte $2B,%10010011 + !byte $2D,%01110011 + !byte $2F,%01010011 + !byte $31,%00110011 + !byte $33,%00010011 + !byte $35,%11010010 + !byte $37,%10110010 + !byte $39,%10010010 + !byte $3B,%01110010 + !byte $3B,%01010010 + !byte $3D,%00110010 + !byte $3F,%00010010 + !byte $41,%11010001 + !byte $41,%10110001 + !byte $43,%10010001 + !byte $45,%01110001 + !byte $47,%00110001 + !byte $49,%00010001 + !byte $49,%11010000 + !byte $4B,%10110000 + !byte $4D,%01110000 + !byte $4F,%01010000 + !byte $4F,%00110000 + !byte $51,%00010000 + !byte $51,%11001111 + !byte $53,%10101111 + !byte $53,%10001111 + !byte $55,%01101111 + !byte $55,%01001111 + !byte $57,%00101111 + !byte $57,%00001111 + !byte $59,%10101110 + !byte $5B,%01101110 + !byte $5D,%00101110 + !byte $5D,%00001110 + !byte $5F,%10101101 + !byte $5F,%10001101 + !byte $27,%11010011 + !byte $29,%11010011 + !byte $29,%10110011 + !byte $2B,%10110011 + !byte $2D,%10010011 + !byte $2F,%01110011 + !byte $31,%01010011 + !byte $33,%00110011 + !byte $35,%00010011 + !byte $37,%11010010 + !byte $39,%10110010 + !byte $3B,%10010010 + !byte $3D,%01010010 + !byte $3F,%00110010 + !byte $41,%00010010 + !byte $43,%10110001 + !byte $45,%10010001 + !byte $47,%01110001 + !byte $47,%01010001 + !byte $49,%00110001 + !byte $4B,%11010000 + !byte $4D,%10110000 + !byte $4D,%10010000 + !byte $4F,%01110000 + !byte $51,%00110000 + !byte $53,%11001111 + !byte $55,%10001111 + !byte $57,%01001111 + !byte $59,%00001111 + !byte $59,%11001110 + !byte $5B,%10101110 + !byte $5B,%10001110 + !byte $5D,%01001110 + !byte $5F,%00001110 + !byte $5F,%11001101 + !byte $2B,%11010011 + !byte $2D,%10110011 + !byte $2F,%10010011 + !byte $31,%01110011 + !byte $33,%01010011 + !byte $35,%00110011 + !byte $37,%00010011 + !byte $39,%11010010 + !byte $3B,%10110010 + !byte $3D,%10010010 + !byte $3D,%01110010 + !byte $3F,%01010010 + !byte $41,%00110010 + !byte $43,%00010010 + !byte $43,%11010001 + !byte $45,%10110001 + !byte $47,%10010001 + !byte $49,%01010001 + !byte $4B,%00110001 + !byte $4B,%00010001 + !byte $4D,%11010000 + !byte $4F,%10010000 + !byte $51,%01010000 + !byte $53,%00010000 + !byte $55,%10101111 + !byte $57,%01101111 + !byte $59,%00101111 + !byte $5B,%11001110 + !byte $5D,%10001110 + !byte $5D,%01101110 + !byte $5F,%00101110 + !byte $2D,%11010011 + !byte $2F,%10110011 + !byte $31,%10010011 + !byte $33,%01110011 + !byte $35,%01010011 + !byte $37,%00110011 + !byte $39,%00010011 + !byte $3B,%11010010 + !byte $3D,%10110010 + !byte $3F,%01110010 + !byte $41,%01010010 + !byte $43,%00110010 + !byte $45,%11010001 + !byte $47,%10110001 + !byte $49,%01110001 + !byte $4B,%01010001 + !byte $4D,%00010001 + !byte $4F,%10110000 + !byte $51,%10010000 + !byte $51,%01110000 + !byte $53,%01010000 + !byte $53,%00110000 + !byte $55,%00010000 + !byte $55,%11001111 + !byte $57,%10101111 + !byte $57,%10001111 + !byte $59,%01101111 + !byte $59,%01001111 + !byte $5B,%00001111 + !byte $5D,%10101110 + !byte $5F,%01101110 + !byte $5F,%01001110 + !byte $2F,%11010011 + !byte $31,%10110011 + !byte $33,%10010011 + !byte $35,%01110011 + !byte $37,%01010011 + !byte $39,%00110011 + !byte $3B,%00010011 + !byte $3D,%11010010 + !byte $3F,%10110010 + !byte $3F,%10010010 + !byte $41,%01110010 + !byte $43,%01010010 + !byte $45,%00110010 + !byte $45,%00010010 + !byte $47,%11010001 + !byte $49,%10110001 + !byte $49,%10010001 + !byte $4B,%01110001 + !byte $4D,%00110001 + !byte $4F,%00010001 + !byte $4F,%11010000 + !byte $51,%10110000 + !byte $53,%01110000 + !byte $55,%00110000 + !byte $57,%11001111 + !byte $59,%10001111 + !byte $5B,%01001111 + !byte $5B,%00101111 + !byte $5D,%11001110 + !byte $5F,%10001110 + !byte $31,%11010011 + !byte $33,%10110011 + !byte $35,%10010011 + !byte $37,%01110011 + !byte $39,%01010011 + !byte $3B,%00110011 + !byte $3D,%00010011 + !byte $3F,%11010010 + !byte $41,%10010010 + !byte $43,%01110010 + !byte $45,%01010010 + !byte $47,%00010010 + !byte $49,%11010001 + !byte $4B,%10010001 + !byte $4D,%01110001 + !byte $4D,%01010001 + !byte $4F,%00110001 + !byte $51,%11010000 + !byte $53,%10010000 + !byte $55,%01010000 + !byte $57,%00010000 + !byte $59,%10101111 + !byte $5B,%01101111 + !byte $5D,%00101111 + !byte $5D,%00001111 + !byte $5F,%10101110 + !byte $33,%11010011 + !byte $35,%11010011 + !byte $35,%10110011 + !byte $37,%10110011 + !byte $37,%10010011 + !byte $39,%01110011 + !byte $3B,%01010011 + !byte $3D,%00110011 + !byte $3F,%00010011 + !byte $41,%11010010 + !byte $41,%10110010 + !byte $43,%10010010 + !byte $45,%01110010 + !byte $47,%01010010 + !byte $47,%00110010 + !byte $49,%00010010 + !byte $4B,%10110001 + !byte $4D,%10010001 + !byte $4F,%01010001 + !byte $51,%00010001 + !byte $53,%11010000 + !byte $53,%10110000 + !byte $55,%10010000 + !byte $55,%01110000 + !byte $57,%01010000 + !byte $57,%00110000 + !byte $59,%00010000 + !byte $59,%11001111 + !byte $5B,%10101111 + !byte $5B,%10001111 + !byte $5D,%01001111 + !byte $5F,%00001111 + !byte $5F,%11001110 + !byte $37,%11010011 + !byte $39,%10110011 + !byte $39,%10010011 + !byte $3B,%01110011 + !byte $3D,%01010011 + !byte $3F,%00110011 + !byte $41,%00010011 + !byte $43,%10110010 + !byte $45,%10010010 + !byte $47,%01110010 + !byte $49,%00110010 + !byte $4B,%00010010 + !byte $4B,%11010001 + !byte $4D,%10110001 + !byte $4F,%01110001 + !byte $51,%01010001 + !byte $51,%00110001 + !byte $53,%00010001 + !byte $55,%10110000 + !byte $57,%01110000 + !byte $59,%00110000 + !byte $5B,%11001111 + !byte $5D,%10001111 + !byte $5D,%01101111 + !byte $5F,%00101111 + !byte $39,%11010011 + !byte $3B,%10110011 + !byte $3B,%10010011 + !byte $3D,%01110011 + !byte $3F,%01010011 + !byte $41,%00110011 + !byte $43,%00010011 + !byte $43,%11010010 + !byte $45,%10110010 + !byte $47,%10010010 + !byte $49,%01010010 + !byte $4B,%00110010 + !byte $4D,%11010001 + !byte $4F,%10110001 + !byte $4F,%10010001 + !byte $51,%01110001 + !byte $53,%00110001 + !byte $55,%11010000 + !byte $57,%10010000 + !byte $59,%01010000 + !byte $5B,%00010000 + !byte $5D,%10101111 + !byte $5F,%01101111 + !byte $5F,%01001111 + !byte $3B,%11010011 + !byte $3D,%10010011 + !byte $3F,%01110011 + !byte $41,%01010011 + !byte $43,%00110011 + !byte $45,%11010010 + !byte $47,%10110010 + !byte $49,%10010010 + !byte $49,%01110010 + !byte $4B,%01010010 + !byte $4D,%00010010 + !byte $4F,%11010001 + !byte $51,%10010001 + !byte $53,%01010001 + !byte $55,%00110001 + !byte $55,%00010001 + !byte $57,%11010000 + !byte $57,%10110000 + !byte $59,%10010000 + !byte $59,%01110000 + !byte $5B,%01010000 + !byte $5B,%00110000 + !byte $5D,%00010000 + !byte $5D,%11001111 + !byte $5F,%10001111 + !byte $3D,%11010011 + !byte $3D,%10110011 + !byte $3F,%10010011 + !byte $41,%01110011 + !byte $43,%01010011 + !byte $45,%00110011 + !byte $45,%00010011 + !byte $47,%11010010 + !byte $49,%10110010 + !byte $4B,%01110010 + !byte $4D,%01010010 + !byte $4D,%00110010 + !byte $4F,%00010010 + !byte $51,%10110001 + !byte $53,%10010001 + !byte $53,%01110001 + !byte $55,%01010001 + !byte $57,%00010001 + !byte $59,%10110000 + !byte $5B,%01110000 + !byte $5D,%00110000 + !byte $5F,%11001111 + !byte $5F,%10101111 + !byte $3F,%11010011 + !byte $3F,%10110011 + !byte $41,%10010011 + !byte $43,%01110011 + !byte $45,%01010011 + !byte $47,%00010011 + !byte $49,%11010010 + !byte $4B,%10110010 + !byte $4B,%10010010 + !byte $4D,%01110010 + !byte $4F,%00110010 + !byte $51,%00010010 + !byte $51,%11010001 + !byte $53,%10110001 + !byte $55,%01110001 + !byte $57,%00110001 + !byte $59,%11010000 + !byte $5B,%10010000 + !byte $5D,%01010000 + !byte $5F,%00010000 + !byte $41,%10110011 + !byte $43,%10010011 + !byte $45,%01110011 + !byte $47,%01010011 + !byte $47,%00110011 + !byte $49,%00010011 + !byte $4B,%11010010 + !byte $4D,%10010010 + !byte $4F,%01110010 + !byte $4F,%01010010 + !byte $51,%00110010 + !byte $53,%11010001 + !byte $55,%10010001 + !byte $57,%01010001 + !byte $59,%00110001 + !byte $59,%00010001 + !byte $5B,%11010000 + !byte $5B,%10110000 + !byte $5D,%01110000 + !byte $5F,%00110000 + !byte $41,%11010011 + !byte $43,%10110011 + !byte $45,%10010011 + !byte $47,%01110011 + !byte $49,%00110011 + !byte $4B,%00010011 + !byte $4D,%10110010 + !byte $4F,%10010010 + !byte $51,%01010010 + !byte $53,%00010010 + !byte $55,%11010001 + !byte $55,%10110001 + !byte $57,%10010001 + !byte $57,%01110001 + !byte $59,%01010001 + !byte $5B,%00010001 + !byte $5D,%10110000 + !byte $5D,%10010000 + !byte $5F,%01110000 + !byte $5F,%01010000 + !byte $43,%11010011 + !byte $45,%10110011 + !byte $47,%10010011 + !byte $49,%01110011 + !byte $49,%01010011 + !byte $4B,%00110011 + !byte $4D,%00010011 + !byte $4D,%11010010 + !byte $4F,%10110010 + !byte $51,%01110010 + !byte $53,%01010010 + !byte $53,%00110010 + !byte $55,%00010010 + !byte $57,%10110001 + !byte $59,%01110001 + !byte $5B,%00110001 + !byte $5D,%11010000 + !byte $5F,%10010000 + !byte $45,%11010011 + !byte $47,%10110011 + !byte $49,%10010011 + !byte $4B,%01010011 + !byte $4D,%00110011 + !byte $4F,%11010010 + !byte $51,%10110010 + !byte $51,%10010010 + !byte $53,%01110010 + !byte $55,%00110010 + !byte $57,%11010001 + !byte $59,%10110001 + !byte $59,%10010001 + !byte $5B,%01110001 + !byte $5B,%01010001 + !byte $5D,%00110001 + !byte $5D,%00010001 + !byte $5F,%11010000 + !byte $5F,%10110000 + !byte $47,%11010011 + !byte $49,%10110011 + !byte $4B,%01110011 + !byte $4D,%01010011 + !byte $4F,%00010011 + !byte $51,%11010010 + !byte $53,%10010010 + !byte $55,%01010010 + !byte $57,%00110010 + !byte $57,%00010010 + !byte $59,%11010001 + !byte $5B,%10010001 + !byte $5D,%01010001 + !byte $5F,%00010001 + !byte $49,%11010011 + !byte $4B,%10110011 + !byte $4B,%10010011 + !byte $4D,%01110011 + !byte $4F,%01010011 + !byte $4F,%00110011 + !byte $51,%00010011 + !byte $53,%10110010 + !byte $55,%10010010 + !byte $55,%01110010 + !byte $57,%01010010 + !byte $59,%00010010 + !byte $5B,%10110001 + !byte $5D,%01110001 + !byte $5F,%00110001 + !byte $4B,%11010011 + !byte $4D,%10010011 + !byte $4F,%01110011 + !byte $51,%00110011 + !byte $53,%00010011 + !byte $53,%11010010 + !byte $55,%10110010 + !byte $57,%01110010 + !byte $59,%00110010 + !byte $5B,%00010010 + !byte $5B,%11010001 + !byte $5D,%10110001 + !byte $5D,%10010001 + !byte $5F,%01110001 + !byte $5F,%01010001 + !byte $4D,%11010011 + !byte $4D,%10110011 + !byte $4F,%10010011 + !byte $51,%01010011 + !byte $53,%00110011 + !byte $55,%11010010 + !byte $57,%10010010 + !byte $59,%01110010 + !byte $59,%01010010 + !byte $5B,%00110010 + !byte $5D,%11010001 + !byte $5F,%10010001 + !byte $4F,%10110011 + !byte $51,%10010011 + !byte $51,%01110011 + !byte $53,%01010011 + !byte $55,%00110011 + !byte $55,%00010011 + !byte $57,%11010010 + !byte $57,%10110010 + !byte $59,%10010010 + !byte $5B,%01010010 + !byte $5D,%00010010 + !byte $5F,%10110001 + !byte $4F,%11010011 + !byte $51,%10110011 + !byte $53,%01110011 + !byte $55,%01010011 + !byte $57,%00010011 + !byte $59,%10110010 + !byte $5B,%01110010 + !byte $5D,%01010010 + !byte $5D,%00110010 + !byte $5F,%00010010 + !byte $5F,%11010001 + !byte $51,%11010011 + !byte $53,%10110011 + !byte $53,%10010011 + !byte $55,%01110011 + !byte $57,%00110011 + !byte $59,%00010011 + !byte $59,%11010010 + !byte $5B,%10110010 + !byte $5B,%10010010 + !byte $5D,%01110010 + !byte $5F,%00110010 + !byte $53,%11010011 + !byte $55,%10010011 + !byte $57,%01010011 + !byte $59,%00110011 + !byte $5B,%11010010 + !byte $5D,%10010010 + !byte $5F,%01010010 + !byte $55,%10110011 + !byte $57,%10010011 + !byte $57,%01110011 + !byte $59,%01010011 + !byte $5B,%00010011 + !byte $5D,%10110010 + !byte $5F,%10010010 + !byte $5F,%01110010 + !byte $55,%11010011 + !byte $57,%10110011 + !byte $59,%01110011 + !byte $5B,%01010011 + !byte $5B,%00110011 + !byte $5D,%00010011 + !byte $5D,%11010010 + !byte $5F,%10110010 + !byte $57,%11010011 + !byte $59,%10010011 + !byte $5B,%01110011 + !byte $5D,%00110011 + !byte $5F,%11010010 + !byte $59,%11010011 + !byte $59,%10110011 + !byte $5B,%10010011 + !byte $5D,%01010011 + !byte $5F,%00010011 + !byte $5B,%10110011 + !byte $5D,%10010011 + !byte $5D,%01110011 + !byte $5F,%01010011 + !byte $5F,%00110011 + !byte $5B,%11010011 + !byte $5D,%10110011 + !byte $5F,%01110011 + !byte $5D,%11010011 + !byte $5F,%10010011 + !byte $5F,%10110011 + !byte $5F,%11010011 diff --git a/src/fx/fx.hgr.corner4.out.a b/src/fx/fx.hgr.corner4.out.a new file mode 100644 index 000000000..81c158085 --- /dev/null +++ b/src/fx/fx.hgr.corner4.out.a @@ -0,0 +1,14 @@ +;license:MIT +;(c) 2019 by 4am +; +!cpu 6502 +!to "build/FX/CORNER4.OUT",plain +*=$6000 + + !source "src/fx/fx.hgr.precomputed.1bit.a" + + +FX_PRECOMPUTED_1BIT Coordinates + +Coordinates + !source "src/fx/fx.hgr.corner4.out.data.a" + !byte $80 diff --git a/src/fx/fx.hgr.corner4.out.data.a b/src/fx/fx.hgr.corner4.out.data.a new file mode 100644 index 000000000..198adde98 --- /dev/null +++ b/src/fx/fx.hgr.corner4.out.data.a @@ -0,0 +1,6720 @@ + !byte $5F,%11010011 + !byte $5F,%10110011 + !byte $5F,%10010011 + !byte $5D,%11010011 + !byte $5F,%01110011 + !byte $5D,%10110011 + !byte $5B,%11010011 + !byte $5F,%00110011 + !byte $5F,%01010011 + !byte $5D,%01110011 + !byte $5D,%10010011 + !byte $5B,%10110011 + !byte $5F,%00010011 + !byte $5D,%01010011 + !byte $5B,%10010011 + !byte $59,%10110011 + !byte $59,%11010011 + !byte $5F,%11010010 + !byte $5D,%00110011 + !byte $5B,%01110011 + !byte $59,%10010011 + !byte $57,%11010011 + !byte $5F,%10110010 + !byte $5D,%11010010 + !byte $5D,%00010011 + !byte $5B,%00110011 + !byte $5B,%01010011 + !byte $59,%01110011 + !byte $57,%10110011 + !byte $55,%11010011 + !byte $5F,%01110010 + !byte $5F,%10010010 + !byte $5D,%10110010 + !byte $5B,%00010011 + !byte $59,%01010011 + !byte $57,%01110011 + !byte $57,%10010011 + !byte $55,%10110011 + !byte $5F,%01010010 + !byte $5D,%10010010 + !byte $5B,%11010010 + !byte $59,%00110011 + !byte $57,%01010011 + !byte $55,%10010011 + !byte $53,%11010011 + !byte $5F,%00110010 + !byte $5D,%01110010 + !byte $5B,%10010010 + !byte $5B,%10110010 + !byte $59,%11010010 + !byte $59,%00010011 + !byte $57,%00110011 + !byte $55,%01110011 + !byte $53,%10010011 + !byte $53,%10110011 + !byte $51,%11010011 + !byte $5F,%11010001 + !byte $5F,%00010010 + !byte $5D,%00110010 + !byte $5D,%01010010 + !byte $5B,%01110010 + !byte $59,%10110010 + !byte $57,%00010011 + !byte $55,%01010011 + !byte $53,%01110011 + !byte $51,%10110011 + !byte $4F,%11010011 + !byte $5F,%10110001 + !byte $5D,%00010010 + !byte $5B,%01010010 + !byte $59,%10010010 + !byte $57,%10110010 + !byte $57,%11010010 + !byte $55,%00010011 + !byte $55,%00110011 + !byte $53,%01010011 + !byte $51,%01110011 + !byte $51,%10010011 + !byte $4F,%10110011 + !byte $5F,%10010001 + !byte $5D,%11010001 + !byte $5B,%00110010 + !byte $59,%01010010 + !byte $59,%01110010 + !byte $57,%10010010 + !byte $55,%11010010 + !byte $53,%00110011 + !byte $51,%01010011 + !byte $4F,%10010011 + !byte $4D,%10110011 + !byte $4D,%11010011 + !byte $5F,%01010001 + !byte $5F,%01110001 + !byte $5D,%10010001 + !byte $5D,%10110001 + !byte $5B,%11010001 + !byte $5B,%00010010 + !byte $59,%00110010 + !byte $57,%01110010 + !byte $55,%10110010 + !byte $53,%11010010 + !byte $53,%00010011 + !byte $51,%00110011 + !byte $4F,%01110011 + !byte $4D,%10010011 + !byte $4B,%11010011 + !byte $5F,%00110001 + !byte $5D,%01110001 + !byte $5B,%10110001 + !byte $59,%00010010 + !byte $57,%01010010 + !byte $55,%01110010 + !byte $55,%10010010 + !byte $53,%10110010 + !byte $51,%00010011 + !byte $4F,%00110011 + !byte $4F,%01010011 + !byte $4D,%01110011 + !byte $4B,%10010011 + !byte $4B,%10110011 + !byte $49,%11010011 + !byte $5F,%00010001 + !byte $5D,%01010001 + !byte $5B,%10010001 + !byte $59,%11010001 + !byte $57,%00010010 + !byte $57,%00110010 + !byte $55,%01010010 + !byte $53,%10010010 + !byte $51,%11010010 + !byte $4F,%00010011 + !byte $4D,%01010011 + !byte $4B,%01110011 + !byte $49,%10110011 + !byte $47,%11010011 + !byte $5F,%10110000 + !byte $5F,%11010000 + !byte $5D,%00010001 + !byte $5D,%00110001 + !byte $5B,%01010001 + !byte $5B,%01110001 + !byte $59,%10010001 + !byte $59,%10110001 + !byte $57,%11010001 + !byte $55,%00110010 + !byte $53,%01110010 + !byte $51,%10010010 + !byte $51,%10110010 + !byte $4F,%11010010 + !byte $4D,%00110011 + !byte $4B,%01010011 + !byte $49,%10010011 + !byte $47,%10110011 + !byte $45,%11010011 + !byte $5F,%10010000 + !byte $5D,%11010000 + !byte $5B,%00110001 + !byte $59,%01110001 + !byte $57,%10110001 + !byte $55,%00010010 + !byte $53,%00110010 + !byte $53,%01010010 + !byte $51,%01110010 + !byte $4F,%10110010 + !byte $4D,%11010010 + !byte $4D,%00010011 + !byte $4B,%00110011 + !byte $49,%01010011 + !byte $49,%01110011 + !byte $47,%10010011 + !byte $45,%10110011 + !byte $43,%11010011 + !byte $5F,%01010000 + !byte $5F,%01110000 + !byte $5D,%10010000 + !byte $5D,%10110000 + !byte $5B,%00010001 + !byte $59,%01010001 + !byte $57,%01110001 + !byte $57,%10010001 + !byte $55,%10110001 + !byte $55,%11010001 + !byte $53,%00010010 + !byte $51,%01010010 + !byte $4F,%10010010 + !byte $4D,%10110010 + !byte $4B,%00010011 + !byte $49,%00110011 + !byte $47,%01110011 + !byte $45,%10010011 + !byte $43,%10110011 + !byte $41,%11010011 + !byte $5F,%00110000 + !byte $5D,%01110000 + !byte $5B,%10110000 + !byte $5B,%11010000 + !byte $59,%00010001 + !byte $59,%00110001 + !byte $57,%01010001 + !byte $55,%10010001 + !byte $53,%11010001 + !byte $51,%00110010 + !byte $4F,%01010010 + !byte $4F,%01110010 + !byte $4D,%10010010 + !byte $4B,%11010010 + !byte $49,%00010011 + !byte $47,%00110011 + !byte $47,%01010011 + !byte $45,%01110011 + !byte $43,%10010011 + !byte $41,%10110011 + !byte $5F,%00010000 + !byte $5D,%01010000 + !byte $5B,%10010000 + !byte $59,%11010000 + !byte $57,%00110001 + !byte $55,%01110001 + !byte $53,%10110001 + !byte $51,%11010001 + !byte $51,%00010010 + !byte $4F,%00110010 + !byte $4D,%01110010 + !byte $4B,%10010010 + !byte $4B,%10110010 + !byte $49,%11010010 + !byte $47,%00010011 + !byte $45,%01010011 + !byte $43,%01110011 + !byte $41,%10010011 + !byte $3F,%10110011 + !byte $3F,%11010011 + !byte $5F,%10101111 + !byte $5F,%11001111 + !byte $5D,%00110000 + !byte $5B,%01110000 + !byte $59,%10110000 + !byte $57,%00010001 + !byte $55,%01010001 + !byte $53,%01110001 + !byte $53,%10010001 + !byte $51,%10110001 + !byte $4F,%00010010 + !byte $4D,%00110010 + !byte $4D,%01010010 + !byte $4B,%01110010 + !byte $49,%10110010 + !byte $47,%11010010 + !byte $45,%00010011 + !byte $45,%00110011 + !byte $43,%01010011 + !byte $41,%01110011 + !byte $3F,%10010011 + !byte $3D,%10110011 + !byte $3D,%11010011 + !byte $5F,%10001111 + !byte $5D,%11001111 + !byte $5D,%00010000 + !byte $5B,%00110000 + !byte $5B,%01010000 + !byte $59,%01110000 + !byte $59,%10010000 + !byte $57,%10110000 + !byte $57,%11010000 + !byte $55,%00010001 + !byte $55,%00110001 + !byte $53,%01010001 + !byte $51,%10010001 + !byte $4F,%11010001 + !byte $4D,%00010010 + !byte $4B,%01010010 + !byte $49,%01110010 + !byte $49,%10010010 + !byte $47,%10110010 + !byte $45,%11010010 + !byte $43,%00110011 + !byte $41,%01010011 + !byte $3F,%01110011 + !byte $3D,%10010011 + !byte $3B,%11010011 + !byte $5F,%01001111 + !byte $5F,%01101111 + !byte $5D,%10101111 + !byte $5B,%00010000 + !byte $59,%01010000 + !byte $57,%10010000 + !byte $55,%11010000 + !byte $53,%00110001 + !byte $51,%01110001 + !byte $4F,%10010001 + !byte $4F,%10110001 + !byte $4D,%11010001 + !byte $4B,%00110010 + !byte $49,%01010010 + !byte $47,%10010010 + !byte $45,%10110010 + !byte $43,%11010010 + !byte $43,%00010011 + !byte $41,%00110011 + !byte $3F,%01010011 + !byte $3D,%01110011 + !byte $3B,%10010011 + !byte $3B,%10110011 + !byte $39,%11010011 + !byte $5F,%00101111 + !byte $5D,%01101111 + !byte $5D,%10001111 + !byte $5B,%11001111 + !byte $59,%00110000 + !byte $57,%01110000 + !byte $55,%10110000 + !byte $53,%00010001 + !byte $51,%00110001 + !byte $51,%01010001 + !byte $4F,%01110001 + !byte $4D,%10110001 + !byte $4B,%11010001 + !byte $4B,%00010010 + !byte $49,%00110010 + !byte $47,%01110010 + !byte $45,%10010010 + !byte $43,%10110010 + !byte $41,%00010011 + !byte $3F,%00110011 + !byte $3D,%01010011 + !byte $3B,%01110011 + !byte $39,%10010011 + !byte $39,%10110011 + !byte $37,%11010011 + !byte $5F,%11001110 + !byte $5F,%00001111 + !byte $5D,%01001111 + !byte $5B,%10001111 + !byte $5B,%10101111 + !byte $59,%11001111 + !byte $59,%00010000 + !byte $57,%00110000 + !byte $57,%01010000 + !byte $55,%01110000 + !byte $55,%10010000 + !byte $53,%10110000 + !byte $53,%11010000 + !byte $51,%00010001 + !byte $4F,%01010001 + !byte $4D,%10010001 + !byte $4B,%10110001 + !byte $49,%00010010 + !byte $47,%00110010 + !byte $47,%01010010 + !byte $45,%01110010 + !byte $43,%10010010 + !byte $41,%10110010 + !byte $41,%11010010 + !byte $3F,%00010011 + !byte $3D,%00110011 + !byte $3B,%01010011 + !byte $39,%01110011 + !byte $37,%10010011 + !byte $37,%10110011 + !byte $35,%10110011 + !byte $35,%11010011 + !byte $33,%11010011 + !byte $5F,%10101110 + !byte $5D,%00001111 + !byte $5D,%00101111 + !byte $5B,%01101111 + !byte $59,%10101111 + !byte $57,%00010000 + !byte $55,%01010000 + !byte $53,%10010000 + !byte $51,%11010000 + !byte $4F,%00110001 + !byte $4D,%01010001 + !byte $4D,%01110001 + !byte $4B,%10010001 + !byte $49,%11010001 + !byte $47,%00010010 + !byte $45,%01010010 + !byte $43,%01110010 + !byte $41,%10010010 + !byte $3F,%11010010 + !byte $3D,%00010011 + !byte $3B,%00110011 + !byte $39,%01010011 + !byte $37,%01110011 + !byte $35,%10010011 + !byte $33,%10110011 + !byte $31,%11010011 + !byte $5F,%10001110 + !byte $5D,%11001110 + !byte $5B,%00101111 + !byte $5B,%01001111 + !byte $59,%10001111 + !byte $57,%11001111 + !byte $55,%00110000 + !byte $53,%01110000 + !byte $51,%10110000 + !byte $4F,%11010000 + !byte $4F,%00010001 + !byte $4D,%00110001 + !byte $4B,%01110001 + !byte $49,%10010001 + !byte $49,%10110001 + !byte $47,%11010001 + !byte $45,%00010010 + !byte $45,%00110010 + !byte $43,%01010010 + !byte $41,%01110010 + !byte $3F,%10010010 + !byte $3F,%10110010 + !byte $3D,%11010010 + !byte $3B,%00010011 + !byte $39,%00110011 + !byte $37,%01010011 + !byte $35,%01110011 + !byte $33,%10010011 + !byte $31,%10110011 + !byte $2F,%11010011 + !byte $5F,%01001110 + !byte $5F,%01101110 + !byte $5D,%10101110 + !byte $5B,%00001111 + !byte $59,%01001111 + !byte $59,%01101111 + !byte $57,%10001111 + !byte $57,%10101111 + !byte $55,%11001111 + !byte $55,%00010000 + !byte $53,%00110000 + !byte $53,%01010000 + !byte $51,%01110000 + !byte $51,%10010000 + !byte $4F,%10110000 + !byte $4D,%00010001 + !byte $4B,%01010001 + !byte $49,%01110001 + !byte $47,%10110001 + !byte $45,%11010001 + !byte $43,%00110010 + !byte $41,%01010010 + !byte $3F,%01110010 + !byte $3D,%10110010 + !byte $3B,%11010010 + !byte $39,%00010011 + !byte $37,%00110011 + !byte $35,%01010011 + !byte $33,%01110011 + !byte $31,%10010011 + !byte $2F,%10110011 + !byte $2D,%11010011 + !byte $5F,%00101110 + !byte $5D,%01101110 + !byte $5D,%10001110 + !byte $5B,%11001110 + !byte $59,%00101111 + !byte $57,%01101111 + !byte $55,%10101111 + !byte $53,%00010000 + !byte $51,%01010000 + !byte $4F,%10010000 + !byte $4D,%11010000 + !byte $4B,%00010001 + !byte $4B,%00110001 + !byte $49,%01010001 + !byte $47,%10010001 + !byte $45,%10110001 + !byte $43,%11010001 + !byte $43,%00010010 + !byte $41,%00110010 + !byte $3F,%01010010 + !byte $3D,%01110010 + !byte $3D,%10010010 + !byte $3B,%10110010 + !byte $39,%11010010 + !byte $37,%00010011 + !byte $35,%00110011 + !byte $33,%01010011 + !byte $31,%01110011 + !byte $2F,%10010011 + !byte $2D,%10110011 + !byte $2B,%11010011 + !byte $5F,%11001101 + !byte $5F,%00001110 + !byte $5D,%01001110 + !byte $5B,%10001110 + !byte $5B,%10101110 + !byte $59,%11001110 + !byte $59,%00001111 + !byte $57,%01001111 + !byte $55,%10001111 + !byte $53,%11001111 + !byte $51,%00110000 + !byte $4F,%01110000 + !byte $4D,%10010000 + !byte $4D,%10110000 + !byte $4B,%11010000 + !byte $49,%00110001 + !byte $47,%01010001 + !byte $47,%01110001 + !byte $45,%10010001 + !byte $43,%10110001 + !byte $41,%00010010 + !byte $3F,%00110010 + !byte $3D,%01010010 + !byte $3B,%10010010 + !byte $39,%10110010 + !byte $37,%11010010 + !byte $35,%00010011 + !byte $33,%00110011 + !byte $31,%01010011 + !byte $2F,%01110011 + !byte $2D,%10010011 + !byte $2B,%10110011 + !byte $29,%10110011 + !byte $29,%11010011 + !byte $27,%11010011 + !byte $5F,%10001101 + !byte $5F,%10101101 + !byte $5D,%00001110 + !byte $5D,%00101110 + !byte $5B,%01101110 + !byte $59,%10101110 + !byte $57,%00001111 + !byte $57,%00101111 + !byte $55,%01001111 + !byte $55,%01101111 + !byte $53,%10001111 + !byte $53,%10101111 + !byte $51,%11001111 + !byte $51,%00010000 + !byte $4F,%00110000 + !byte $4F,%01010000 + !byte $4D,%01110000 + !byte $4B,%10110000 + !byte $49,%11010000 + !byte $49,%00010001 + !byte $47,%00110001 + !byte $45,%01110001 + !byte $43,%10010001 + !byte $41,%10110001 + !byte $41,%11010001 + !byte $3F,%00010010 + !byte $3D,%00110010 + !byte $3B,%01010010 + !byte $3B,%01110010 + !byte $39,%10010010 + !byte $37,%10110010 + !byte $35,%11010010 + !byte $33,%00010011 + !byte $31,%00110011 + !byte $2F,%01010011 + !byte $2D,%01110011 + !byte $2B,%10010011 + !byte $29,%10010011 + !byte $27,%10110011 + !byte $25,%11010011 + !byte $5F,%01101101 + !byte $5D,%11001101 + !byte $5B,%00101110 + !byte $5B,%01001110 + !byte $59,%10001110 + !byte $57,%11001110 + !byte $55,%00101111 + !byte $53,%01101111 + !byte $51,%10101111 + !byte $4F,%00010000 + !byte $4D,%01010000 + !byte $4B,%10010000 + !byte $49,%10110000 + !byte $47,%00010001 + !byte $45,%00110001 + !byte $45,%01010001 + !byte $43,%01110001 + !byte $41,%10010001 + !byte $3F,%11010001 + !byte $3D,%00010010 + !byte $3B,%00110010 + !byte $39,%01110010 + !byte $37,%10010010 + !byte $35,%10110010 + !byte $33,%11010010 + !byte $31,%00010011 + !byte $2F,%00110011 + !byte $2D,%01010011 + !byte $2B,%01110011 + !byte $29,%01110011 + !byte $27,%10010011 + !byte $25,%10110011 + !byte $23,%11010011 + !byte $21,%11010011 + !byte $5F,%00101101 + !byte $5F,%01001101 + !byte $5D,%10001101 + !byte $5D,%10101101 + !byte $5B,%00001110 + !byte $59,%01001110 + !byte $59,%01101110 + !byte $57,%10001110 + !byte $57,%10101110 + !byte $55,%00001111 + !byte $53,%01001111 + !byte $51,%10001111 + !byte $4F,%11001111 + !byte $4D,%00010000 + !byte $4D,%00110000 + !byte $4B,%01010000 + !byte $4B,%01110000 + !byte $49,%10010000 + !byte $47,%11010000 + !byte $45,%00010001 + !byte $43,%01010001 + !byte $41,%01110001 + !byte $3F,%10110001 + !byte $3D,%11010001 + !byte $3B,%00010010 + !byte $39,%00110010 + !byte $39,%01010010 + !byte $37,%01110010 + !byte $35,%10010010 + !byte $33,%10110010 + !byte $31,%11010010 + !byte $2F,%00010011 + !byte $2D,%00110011 + !byte $2B,%00110011 + !byte $2B,%01010011 + !byte $29,%01010011 + !byte $27,%01110011 + !byte $25,%10010011 + !byte $23,%10110011 + !byte $21,%10110011 + !byte $1F,%11010011 + !byte $1D,%11010011 + !byte $5F,%00001101 + !byte $5D,%01101101 + !byte $5B,%10101101 + !byte $5B,%11001101 + !byte $59,%00101110 + !byte $57,%01101110 + !byte $55,%10101110 + !byte $55,%11001110 + !byte $53,%00001111 + !byte $53,%00101111 + !byte $51,%01001111 + !byte $51,%01101111 + !byte $4F,%10001111 + !byte $4F,%10101111 + !byte $4D,%11001111 + !byte $4B,%00110000 + !byte $49,%01110000 + !byte $47,%10010000 + !byte $47,%10110000 + !byte $45,%11010000 + !byte $43,%00110001 + !byte $41,%01010001 + !byte $3F,%01110001 + !byte $3F,%10010001 + !byte $3D,%10110001 + !byte $3B,%11010001 + !byte $39,%00010010 + !byte $37,%01010010 + !byte $35,%01110010 + !byte $33,%10010010 + !byte $31,%10110010 + !byte $2F,%11010010 + !byte $2D,%00010011 + !byte $2B,%00010011 + !byte $29,%00110011 + !byte $27,%01010011 + !byte $25,%01110011 + !byte $23,%10010011 + !byte $21,%10010011 + !byte $1F,%10110011 + !byte $1D,%10110011 + !byte $1B,%11010011 + !byte $19,%11010011 + !byte $5F,%10101100 + !byte $5F,%11001100 + !byte $5D,%00101101 + !byte $5D,%01001101 + !byte $5B,%10001101 + !byte $59,%11001101 + !byte $59,%00001110 + !byte $57,%01001110 + !byte $55,%10001110 + !byte $53,%11001110 + !byte $51,%00101111 + !byte $4F,%01101111 + !byte $4D,%10101111 + !byte $4B,%00010000 + !byte $49,%01010000 + !byte $47,%01110000 + !byte $45,%10110000 + !byte $43,%11010000 + !byte $43,%00010001 + !byte $41,%00110001 + !byte $3F,%01010001 + !byte $3D,%10010001 + !byte $3B,%10110001 + !byte $39,%11010001 + !byte $37,%00010010 + !byte $37,%00110010 + !byte $35,%01010010 + !byte $33,%01110010 + !byte $31,%10010010 + !byte $2F,%10110010 + !byte $2D,%11010010 + !byte $2B,%11010010 + !byte $29,%00010011 + !byte $27,%00110011 + !byte $25,%01010011 + !byte $23,%01010011 + !byte $23,%01110011 + !byte $21,%01110011 + !byte $1F,%10010011 + !byte $1D,%10010011 + !byte $1B,%10110011 + !byte $19,%10110011 + !byte $17,%11010011 + !byte $15,%11010011 + !byte $5F,%10001100 + !byte $5D,%00001101 + !byte $5B,%01001101 + !byte $5B,%01101101 + !byte $59,%10101101 + !byte $57,%00001110 + !byte $57,%00101110 + !byte $55,%01101110 + !byte $53,%10101110 + !byte $51,%00001111 + !byte $4F,%01001111 + !byte $4D,%10001111 + !byte $4B,%10101111 + !byte $4B,%11001111 + !byte $49,%00010000 + !byte $49,%00110000 + !byte $47,%01010000 + !byte $45,%10010000 + !byte $43,%10110000 + !byte $41,%00010001 + !byte $3F,%00110001 + !byte $3D,%01010001 + !byte $3D,%01110001 + !byte $3B,%10010001 + !byte $39,%10110001 + !byte $37,%11010001 + !byte $35,%00010010 + !byte $35,%00110010 + !byte $33,%00110010 + !byte $33,%01010010 + !byte $31,%01110010 + !byte $2F,%10010010 + !byte $2D,%10010010 + !byte $2D,%10110010 + !byte $2B,%10110010 + !byte $29,%11010010 + !byte $27,%00010011 + !byte $25,%00110011 + !byte $23,%00110011 + !byte $21,%01010011 + !byte $1F,%01110011 + !byte $1D,%01110011 + !byte $1B,%10010011 + !byte $19,%10010011 + !byte $17,%10110011 + !byte $15,%10110011 + !byte $13,%11010011 + !byte $11,%11010011 + !byte $0F,%11010011 + !byte $5F,%01001100 + !byte $5F,%01101100 + !byte $5D,%10101100 + !byte $5D,%11001100 + !byte $5B,%00101101 + !byte $59,%01101101 + !byte $59,%10001101 + !byte $57,%11001101 + !byte $55,%00101110 + !byte $55,%01001110 + !byte $53,%01101110 + !byte $53,%10001110 + !byte $51,%10101110 + !byte $51,%11001110 + !byte $4F,%00001111 + !byte $4F,%00101111 + !byte $4D,%01001111 + !byte $4D,%01101111 + !byte $4B,%10001111 + !byte $49,%11001111 + !byte $47,%00110000 + !byte $45,%01010000 + !byte $45,%01110000 + !byte $43,%10010000 + !byte $41,%10110000 + !byte $41,%11010000 + !byte $3F,%00010001 + !byte $3D,%00110001 + !byte $3B,%01110001 + !byte $39,%10010001 + !byte $37,%10110001 + !byte $35,%11010001 + !byte $33,%00010010 + !byte $31,%00110010 + !byte $31,%01010010 + !byte $2F,%01010010 + !byte $2F,%01110010 + !byte $2D,%01110010 + !byte $2B,%10010010 + !byte $29,%10110010 + !byte $27,%11010010 + !byte $25,%00010011 + !byte $23,%00010011 + !byte $21,%00110011 + !byte $1F,%01010011 + !byte $1D,%01010011 + !byte $1B,%01110011 + !byte $19,%01110011 + !byte $17,%10010011 + !byte $15,%10010011 + !byte $13,%10110011 + !byte $11,%10110011 + !byte $0F,%10110011 + !byte $0D,%11010011 + !byte $0B,%11010011 + !byte $09,%11010011 + !byte $07,%11010011 + !byte $05,%11010011 + !byte $03,%11010011 + !byte $01,%11010011 + !byte $5F,%00101100 + !byte $5D,%10001100 + !byte $5B,%11001100 + !byte $5B,%00001101 + !byte $59,%01001101 + !byte $57,%10001101 + !byte $57,%10101101 + !byte $55,%00001110 + !byte $53,%01001110 + !byte $51,%10001110 + !byte $4F,%11001110 + !byte $4D,%00101111 + !byte $4B,%01101111 + !byte $49,%10101111 + !byte $47,%11001111 + !byte $47,%00010000 + !byte $45,%00110000 + !byte $43,%01110000 + !byte $41,%10010000 + !byte $3F,%11010000 + !byte $3D,%00010001 + !byte $3B,%00110001 + !byte $3B,%01010001 + !byte $39,%01110001 + !byte $37,%10010001 + !byte $35,%10110001 + !byte $33,%11010001 + !byte $31,%00010010 + !byte $2F,%00110010 + !byte $2D,%01010010 + !byte $2B,%01110010 + !byte $29,%10010010 + !byte $27,%10110010 + !byte $25,%11010010 + !byte $23,%11010010 + !byte $21,%00010011 + !byte $1F,%00110011 + !byte $1D,%00110011 + !byte $1B,%01010011 + !byte $19,%01010011 + !byte $17,%01110011 + !byte $15,%01110011 + !byte $13,%10010011 + !byte $11,%10010011 + !byte $0F,%10010011 + !byte $0D,%10110011 + !byte $0B,%10110011 + !byte $09,%10110011 + !byte $07,%10110011 + !byte $05,%10110011 + !byte $03,%10110011 + !byte $01,%10110011 + !byte $5F,%11001011 + !byte $5F,%00001100 + !byte $5D,%01001100 + !byte $5D,%01101100 + !byte $5B,%10101100 + !byte $59,%00001101 + !byte $59,%00101101 + !byte $57,%01101101 + !byte $55,%10101101 + !byte $55,%11001101 + !byte $53,%00101110 + !byte $51,%01101110 + !byte $4F,%10101110 + !byte $4D,%00001111 + !byte $4B,%01001111 + !byte $49,%10001111 + !byte $47,%10101111 + !byte $45,%00010000 + !byte $43,%01010000 + !byte $41,%01110000 + !byte $3F,%10110000 + !byte $3D,%11010000 + !byte $3B,%00010001 + !byte $39,%01010001 + !byte $37,%01110001 + !byte $35,%10010001 + !byte $33,%10110001 + !byte $31,%11010001 + !byte $2F,%00010010 + !byte $2D,%00110010 + !byte $2B,%01010010 + !byte $29,%01110010 + !byte $27,%10010010 + !byte $25,%10110010 + !byte $23,%10110010 + !byte $21,%11010010 + !byte $1F,%00010011 + !byte $1D,%00010011 + !byte $1B,%00110011 + !byte $19,%00110011 + !byte $17,%01010011 + !byte $15,%01010011 + !byte $13,%01110011 + !byte $11,%01110011 + !byte $0F,%01110011 + !byte $0D,%10010011 + !byte $0B,%10010011 + !byte $09,%10010011 + !byte $07,%10010011 + !byte $05,%10010011 + !byte $03,%10010011 + !byte $01,%10010011 + !byte $5F,%10001011 + !byte $5F,%10101011 + !byte $5D,%00001100 + !byte $5D,%00101100 + !byte $5B,%01101100 + !byte $5B,%10001100 + !byte $59,%11001100 + !byte $57,%00101101 + !byte $57,%01001101 + !byte $55,%10001101 + !byte $53,%11001101 + !byte $53,%00001110 + !byte $51,%00101110 + !byte $51,%01001110 + !byte $4F,%10001110 + !byte $4D,%10101110 + !byte $4D,%11001110 + !byte $4B,%00001111 + !byte $4B,%00101111 + !byte $49,%01001111 + !byte $49,%01101111 + !byte $47,%10001111 + !byte $45,%11001111 + !byte $43,%00010000 + !byte $43,%00110000 + !byte $41,%01010000 + !byte $3F,%01110000 + !byte $3F,%10010000 + !byte $3D,%10110000 + !byte $3B,%11010000 + !byte $39,%00010001 + !byte $39,%00110001 + !byte $37,%01010001 + !byte $35,%01110001 + !byte $33,%10010001 + !byte $31,%10110001 + !byte $2F,%11010001 + !byte $2D,%00010010 + !byte $2B,%00110010 + !byte $29,%01010010 + !byte $27,%01110010 + !byte $25,%01110010 + !byte $25,%10010010 + !byte $23,%10010010 + !byte $21,%10110010 + !byte $1F,%11010010 + !byte $1D,%11010010 + !byte $1B,%00010011 + !byte $19,%00010011 + !byte $17,%00110011 + !byte $15,%00110011 + !byte $13,%01010011 + !byte $11,%01010011 + !byte $0F,%01010011 + !byte $0D,%01110011 + !byte $0B,%01110011 + !byte $09,%01110011 + !byte $07,%01110011 + !byte $05,%01110011 + !byte $03,%01110011 + !byte $01,%01110011 + !byte $5F,%01101011 + !byte $5D,%11001011 + !byte $5B,%01001100 + !byte $59,%10001100 + !byte $59,%10101100 + !byte $57,%00001101 + !byte $55,%01001101 + !byte $55,%01101101 + !byte $53,%10101101 + !byte $51,%00001110 + !byte $4F,%01001110 + !byte $4F,%01101110 + !byte $4D,%10001110 + !byte $4B,%11001110 + !byte $49,%00101111 + !byte $47,%01101111 + !byte $45,%10001111 + !byte $45,%10101111 + !byte $43,%11001111 + !byte $41,%00110000 + !byte $3F,%01010000 + !byte $3D,%10010000 + !byte $3B,%10110000 + !byte $39,%11010000 + !byte $37,%00110001 + !byte $35,%01010001 + !byte $33,%01110001 + !byte $31,%10010001 + !byte $2F,%10110001 + !byte $2D,%11010001 + !byte $2B,%00010010 + !byte $29,%00110010 + !byte $27,%01010010 + !byte $25,%01010010 + !byte $23,%01110010 + !byte $21,%10010010 + !byte $1F,%10110010 + !byte $1D,%10110010 + !byte $1B,%11010010 + !byte $19,%11010010 + !byte $17,%00010011 + !byte $15,%00010011 + !byte $13,%00110011 + !byte $11,%00110011 + !byte $0F,%00110011 + !byte $0D,%01010011 + !byte $0B,%01010011 + !byte $09,%01010011 + !byte $07,%01010011 + !byte $05,%01010011 + !byte $03,%01010011 + !byte $01,%01010011 + !byte $5F,%00101011 + !byte $5F,%01001011 + !byte $5D,%10001011 + !byte $5D,%10101011 + !byte $5B,%00001100 + !byte $5B,%00101100 + !byte $59,%01101100 + !byte $57,%10101100 + !byte $57,%11001100 + !byte $55,%00101101 + !byte $53,%01101101 + !byte $53,%10001101 + !byte $51,%10101101 + !byte $51,%11001101 + !byte $4F,%00101110 + !byte $4D,%01101110 + !byte $4B,%10101110 + !byte $49,%00001111 + !byte $47,%01001111 + !byte $45,%01101111 + !byte $43,%10101111 + !byte $41,%00010000 + !byte $3F,%00110000 + !byte $3D,%01010000 + !byte $3D,%01110000 + !byte $3B,%10010000 + !byte $39,%10110000 + !byte $37,%11010000 + !byte $37,%00010001 + !byte $35,%00110001 + !byte $33,%01010001 + !byte $31,%01110001 + !byte $2F,%10010001 + !byte $2D,%10110001 + !byte $2B,%11010001 + !byte $29,%00010010 + !byte $27,%00110010 + !byte $25,%00110010 + !byte $23,%01010010 + !byte $21,%01110010 + !byte $1F,%10010010 + !byte $1D,%10010010 + !byte $1B,%10110010 + !byte $19,%10110010 + !byte $17,%11010010 + !byte $15,%11010010 + !byte $13,%00010011 + !byte $11,%00010011 + !byte $0F,%00010011 + !byte $0D,%00110011 + !byte $0B,%00110011 + !byte $09,%00110011 + !byte $07,%00110011 + !byte $05,%00110011 + !byte $03,%00110011 + !byte $01,%00110011 + !byte $5F,%11001010 + !byte $5F,%00001011 + !byte $5D,%01001011 + !byte $5D,%01101011 + !byte $5B,%10101011 + !byte $5B,%11001011 + !byte $59,%00101100 + !byte $59,%01001100 + !byte $57,%10001100 + !byte $55,%00001101 + !byte $53,%01001101 + !byte $51,%10001101 + !byte $4F,%11001101 + !byte $4F,%00001110 + !byte $4D,%01001110 + !byte $4B,%01101110 + !byte $4B,%10001110 + !byte $49,%10101110 + !byte $49,%11001110 + !byte $47,%00001111 + !byte $47,%00101111 + !byte $45,%01001111 + !byte $43,%10001111 + !byte $41,%10101111 + !byte $41,%11001111 + !byte $3F,%00010000 + !byte $3D,%00110000 + !byte $3B,%01110000 + !byte $39,%10010000 + !byte $37,%10110000 + !byte $35,%00010001 + !byte $33,%00110001 + !byte $31,%01010001 + !byte $2F,%01110001 + !byte $2D,%10010001 + !byte $2B,%10110001 + !byte $29,%11010001 + !byte $27,%00010010 + !byte $25,%00010010 + !byte $23,%00110010 + !byte $21,%01010010 + !byte $1F,%01010010 + !byte $1F,%01110010 + !byte $1D,%01110010 + !byte $1B,%10010010 + !byte $19,%10010010 + !byte $17,%10110010 + !byte $15,%10110010 + !byte $13,%11010010 + !byte $11,%11010010 + !byte $0F,%11010010 + !byte $0D,%00010011 + !byte $0B,%00010011 + !byte $09,%00010011 + !byte $07,%00010011 + !byte $05,%00010011 + !byte $03,%00010011 + !byte $01,%00010011 + !byte $5F,%10001010 + !byte $5F,%10101010 + !byte $5D,%00101011 + !byte $5B,%10001011 + !byte $59,%00001100 + !byte $57,%01001100 + !byte $57,%01101100 + !byte $55,%10101100 + !byte $55,%11001100 + !byte $53,%00101101 + !byte $51,%01101101 + !byte $4F,%10101101 + !byte $4D,%00001110 + !byte $4D,%00101110 + !byte $4B,%01001110 + !byte $49,%10001110 + !byte $47,%11001110 + !byte $45,%00101111 + !byte $43,%01001111 + !byte $43,%01101111 + !byte $41,%10001111 + !byte $3F,%11001111 + !byte $3D,%00010000 + !byte $3B,%00110000 + !byte $3B,%01010000 + !byte $39,%01110000 + !byte $37,%10010000 + !byte $35,%10110000 + !byte $35,%11010000 + !byte $33,%00010001 + !byte $31,%00110001 + !byte $2F,%01010001 + !byte $2D,%01110001 + !byte $2B,%10010001 + !byte $29,%10110001 + !byte $27,%11010001 + !byte $25,%11010001 + !byte $23,%00010010 + !byte $21,%00110010 + !byte $1F,%00110010 + !byte $1D,%01010010 + !byte $1B,%01110010 + !byte $19,%01110010 + !byte $17,%10010010 + !byte $15,%10010010 + !byte $13,%10110010 + !byte $11,%10110010 + !byte $0F,%10110010 + !byte $0D,%11010010 + !byte $0B,%11010010 + !byte $09,%11010010 + !byte $07,%11010010 + !byte $05,%11010010 + !byte $03,%11010010 + !byte $01,%11010010 + !byte $5F,%01101010 + !byte $5D,%11001010 + !byte $5D,%00001011 + !byte $5B,%01001011 + !byte $5B,%01101011 + !byte $59,%10101011 + !byte $59,%11001011 + !byte $57,%00101100 + !byte $55,%01101100 + !byte $55,%10001100 + !byte $53,%11001100 + !byte $53,%00001101 + !byte $51,%00101101 + !byte $51,%01001101 + !byte $4F,%10001101 + !byte $4D,%11001101 + !byte $4B,%00101110 + !byte $49,%01101110 + !byte $47,%10101110 + !byte $45,%00001111 + !byte $43,%00101111 + !byte $41,%01101111 + !byte $3F,%10001111 + !byte $3F,%10101111 + !byte $3D,%11001111 + !byte $3B,%00010000 + !byte $39,%01010000 + !byte $37,%01110000 + !byte $35,%10010000 + !byte $33,%10110000 + !byte $33,%11010000 + !byte $31,%00010001 + !byte $2F,%00110001 + !byte $2D,%01010001 + !byte $2B,%01110001 + !byte $29,%10010001 + !byte $27,%10010001 + !byte $27,%10110001 + !byte $25,%10110001 + !byte $23,%11010001 + !byte $21,%00010010 + !byte $1F,%00010010 + !byte $1D,%00110010 + !byte $1B,%01010010 + !byte $19,%01010010 + !byte $17,%01110010 + !byte $15,%01110010 + !byte $13,%10010010 + !byte $11,%10010010 + !byte $0F,%10010010 + !byte $0D,%10110010 + !byte $0B,%10110010 + !byte $09,%10110010 + !byte $07,%10110010 + !byte $05,%10110010 + !byte $03,%10110010 + !byte $01,%10110010 + !byte $5F,%00101010 + !byte $5F,%01001010 + !byte $5D,%10001010 + !byte $5D,%10101010 + !byte $5B,%00001011 + !byte $5B,%00101011 + !byte $59,%01101011 + !byte $59,%10001011 + !byte $57,%11001011 + !byte $57,%00001100 + !byte $55,%01001100 + !byte $53,%10001100 + !byte $53,%10101100 + !byte $51,%00001101 + !byte $4F,%01001101 + !byte $4F,%01101101 + !byte $4D,%10001101 + !byte $4D,%10101101 + !byte $4B,%00001110 + !byte $49,%01001110 + !byte $47,%01101110 + !byte $47,%10001110 + !byte $45,%10101110 + !byte $45,%11001110 + !byte $43,%00001111 + !byte $41,%01001111 + !byte $3F,%01101111 + !byte $3D,%10101111 + !byte $3B,%11001111 + !byte $39,%00010000 + !byte $39,%00110000 + !byte $37,%01010000 + !byte $35,%01110000 + !byte $33,%10010000 + !byte $31,%11010000 + !byte $2F,%00010001 + !byte $2D,%00110001 + !byte $2B,%01010001 + !byte $29,%01110001 + !byte $27,%01110001 + !byte $25,%10010001 + !byte $23,%10110001 + !byte $21,%11010001 + !byte $1F,%11010001 + !byte $1D,%00010010 + !byte $1B,%00110010 + !byte $19,%00110010 + !byte $17,%01010010 + !byte $15,%01010010 + !byte $13,%01110010 + !byte $11,%01110010 + !byte $0F,%01110010 + !byte $0D,%10010010 + !byte $0B,%10010010 + !byte $09,%10010010 + !byte $07,%10010010 + !byte $05,%10010010 + !byte $03,%10010010 + !byte $01,%10010010 + !byte $5F,%11001001 + !byte $5F,%00001010 + !byte $5D,%01001010 + !byte $5D,%01101010 + !byte $5B,%11001010 + !byte $59,%01001011 + !byte $57,%10101011 + !byte $55,%00001100 + !byte $55,%00101100 + !byte $53,%01101100 + !byte $51,%11001100 + !byte $4F,%00101101 + !byte $4D,%01101101 + !byte $4B,%10101101 + !byte $4B,%11001101 + !byte $49,%00001110 + !byte $49,%00101110 + !byte $47,%01001110 + !byte $45,%10001110 + !byte $43,%11001110 + !byte $41,%00001111 + !byte $41,%00101111 + !byte $3F,%01001111 + !byte $3D,%10001111 + !byte $3B,%10101111 + !byte $39,%11001111 + !byte $37,%00110000 + !byte $35,%01010000 + !byte $33,%01110000 + !byte $31,%10010000 + !byte $31,%10110000 + !byte $2F,%10110000 + !byte $2F,%11010000 + !byte $2D,%00010001 + !byte $2B,%00110001 + !byte $29,%00110001 + !byte $29,%01010001 + !byte $27,%01010001 + !byte $25,%01110001 + !byte $23,%10010001 + !byte $21,%10110001 + !byte $1F,%10110001 + !byte $1D,%11010001 + !byte $1B,%00010010 + !byte $19,%00010010 + !byte $17,%00110010 + !byte $15,%00110010 + !byte $13,%01010010 + !byte $11,%01010010 + !byte $0F,%01010010 + !byte $0D,%01110010 + !byte $0B,%01110010 + !byte $09,%01110010 + !byte $07,%01110010 + !byte $05,%01110010 + !byte $03,%01110010 + !byte $01,%01110010 + !byte $5F,%10001001 + !byte $5F,%10101001 + !byte $5D,%00101010 + !byte $5B,%10001010 + !byte $5B,%10101010 + !byte $59,%00001011 + !byte $59,%00101011 + !byte $57,%01101011 + !byte $57,%10001011 + !byte $55,%11001011 + !byte $53,%00101100 + !byte $53,%01001100 + !byte $51,%10001100 + !byte $51,%10101100 + !byte $4F,%11001100 + !byte $4F,%00001101 + !byte $4D,%01001101 + !byte $4B,%10001101 + !byte $49,%11001101 + !byte $47,%00101110 + !byte $45,%01101110 + !byte $43,%10001110 + !byte $43,%10101110 + !byte $41,%11001110 + !byte $3F,%00101111 + !byte $3D,%01001111 + !byte $3D,%01101111 + !byte $3B,%10001111 + !byte $39,%10101111 + !byte $37,%00010000 + !byte $35,%00110000 + !byte $33,%01010000 + !byte $31,%01110000 + !byte $2F,%10010000 + !byte $2D,%10110000 + !byte $2D,%11010000 + !byte $2B,%11010000 + !byte $2B,%00010001 + !byte $29,%00010001 + !byte $27,%00110001 + !byte $25,%01010001 + !byte $23,%01110001 + !byte $21,%10010001 + !byte $1F,%10010001 + !byte $1D,%10110001 + !byte $1B,%11010001 + !byte $19,%11010001 + !byte $17,%00010010 + !byte $15,%00010010 + !byte $13,%00110010 + !byte $11,%00110010 + !byte $0F,%00110010 + !byte $0D,%01010010 + !byte $0B,%01010010 + !byte $09,%01010010 + !byte $07,%01010010 + !byte $05,%01010010 + !byte $03,%01010010 + !byte $01,%01010010 + !byte $5F,%01001001 + !byte $5F,%01101001 + !byte $5D,%11001001 + !byte $5D,%00001010 + !byte $5B,%01001010 + !byte $5B,%01101010 + !byte $59,%10101010 + !byte $59,%11001010 + !byte $57,%01001011 + !byte $55,%10001011 + !byte $55,%10101011 + !byte $53,%00001100 + !byte $51,%01001100 + !byte $51,%01101100 + !byte $4F,%10101100 + !byte $4D,%00001101 + !byte $4D,%00101101 + !byte $4B,%01001101 + !byte $4B,%01101101 + !byte $49,%10001101 + !byte $49,%10101101 + !byte $47,%00001110 + !byte $45,%00101110 + !byte $45,%01001110 + !byte $43,%01101110 + !byte $41,%10101110 + !byte $3F,%00001111 + !byte $3D,%00101111 + !byte $3B,%01101111 + !byte $39,%10001111 + !byte $37,%10101111 + !byte $37,%11001111 + !byte $35,%00010000 + !byte $33,%00110000 + !byte $31,%01010000 + !byte $2F,%01110000 + !byte $2D,%10010000 + !byte $2B,%10110000 + !byte $29,%11010000 + !byte $27,%00010001 + !byte $25,%00110001 + !byte $23,%01010001 + !byte $21,%01110001 + !byte $1F,%01110001 + !byte $1D,%10010001 + !byte $1B,%10010001 + !byte $1B,%10110001 + !byte $19,%10110001 + !byte $17,%11010001 + !byte $15,%11010001 + !byte $13,%11010001 + !byte $13,%00010010 + !byte $11,%00010010 + !byte $0F,%00010010 + !byte $0D,%00110010 + !byte $0B,%00110010 + !byte $09,%00110010 + !byte $07,%00110010 + !byte $05,%00110010 + !byte $03,%00110010 + !byte $01,%00110010 + !byte $5F,%00001001 + !byte $5F,%00101001 + !byte $5D,%10001001 + !byte $5D,%10101001 + !byte $5B,%00001010 + !byte $5B,%00101010 + !byte $59,%10001010 + !byte $57,%00001011 + !byte $57,%00101011 + !byte $55,%01101011 + !byte $53,%10101011 + !byte $53,%11001011 + !byte $51,%00101100 + !byte $4F,%01101100 + !byte $4F,%10001100 + !byte $4D,%11001100 + !byte $4B,%00101101 + !byte $49,%01101101 + !byte $47,%10101101 + !byte $47,%11001101 + !byte $45,%00001110 + !byte $43,%01001110 + !byte $41,%10001110 + !byte $3F,%10101110 + !byte $3F,%11001110 + !byte $3D,%00001111 + !byte $3B,%00101111 + !byte $3B,%01001111 + !byte $39,%01101111 + !byte $37,%10001111 + !byte $35,%11001111 + !byte $33,%00010000 + !byte $31,%00110000 + !byte $2F,%01010000 + !byte $2D,%01110000 + !byte $2B,%10010000 + !byte $29,%10110000 + !byte $27,%11010000 + !byte $25,%00010001 + !byte $23,%00110001 + !byte $21,%00110001 + !byte $21,%01010001 + !byte $1F,%01010001 + !byte $1D,%01110001 + !byte $1B,%01110001 + !byte $19,%10010001 + !byte $17,%10110001 + !byte $15,%10110001 + !byte $13,%10110001 + !byte $11,%11010001 + !byte $0F,%11010001 + !byte $0D,%00010010 + !byte $0B,%00010010 + !byte $09,%00010010 + !byte $07,%00010010 + !byte $05,%00010010 + !byte $03,%00010010 + !byte $01,%00010010 + !byte $5F,%10101000 + !byte $5F,%11001000 + !byte $5D,%01001001 + !byte $5D,%01101001 + !byte $5B,%11001001 + !byte $59,%01001010 + !byte $59,%01101010 + !byte $57,%10101010 + !byte $57,%11001010 + !byte $55,%00101011 + !byte $55,%01001011 + !byte $53,%10001011 + !byte $51,%00001100 + !byte $4F,%01001100 + !byte $4D,%10001100 + !byte $4D,%10101100 + !byte $4B,%00001101 + !byte $49,%01001101 + !byte $47,%10001101 + !byte $45,%11001101 + !byte $43,%00101110 + !byte $41,%01001110 + !byte $41,%01101110 + !byte $3F,%10001110 + !byte $3D,%11001110 + !byte $3B,%00001111 + !byte $39,%01001111 + !byte $37,%01101111 + !byte $35,%10001111 + !byte $35,%10101111 + !byte $33,%11001111 + !byte $31,%00010000 + !byte $2F,%00110000 + !byte $2D,%01010000 + !byte $2B,%01110000 + !byte $29,%10010000 + !byte $27,%10110000 + !byte $25,%11010000 + !byte $23,%00010001 + !byte $21,%00010001 + !byte $1F,%00110001 + !byte $1D,%01010001 + !byte $1B,%01010001 + !byte $19,%01110001 + !byte $17,%10010001 + !byte $15,%10010001 + !byte $13,%10010001 + !byte $11,%10110001 + !byte $0F,%10110001 + !byte $0D,%11010001 + !byte $0B,%11010001 + !byte $09,%11010001 + !byte $07,%11010001 + !byte $05,%11010001 + !byte $03,%11010001 + !byte $01,%11010001 + !byte $5F,%01101000 + !byte $5F,%10001000 + !byte $5D,%00001001 + !byte $5D,%00101001 + !byte $5B,%10001001 + !byte $5B,%10101001 + !byte $59,%00001010 + !byte $59,%00101010 + !byte $57,%10001010 + !byte $55,%00001011 + !byte $53,%01101011 + !byte $51,%10101011 + !byte $51,%11001011 + !byte $4F,%00101100 + !byte $4D,%01101100 + !byte $4B,%10101100 + !byte $4B,%11001100 + !byte $49,%00101101 + !byte $47,%01001101 + !byte $47,%01101101 + !byte $45,%10101101 + !byte $43,%00001110 + !byte $41,%00101110 + !byte $3F,%01101110 + !byte $3D,%10101110 + !byte $3B,%11001110 + !byte $39,%00001111 + !byte $39,%00101111 + !byte $37,%01001111 + !byte $35,%01101111 + !byte $33,%10101111 + !byte $31,%11001111 + !byte $2F,%00010000 + !byte $2D,%00110000 + !byte $2B,%01010000 + !byte $29,%01110000 + !byte $27,%10010000 + !byte $25,%10110000 + !byte $23,%11010000 + !byte $21,%11010000 + !byte $1F,%00010001 + !byte $1D,%00110001 + !byte $1B,%00110001 + !byte $19,%01010001 + !byte $17,%01110001 + !byte $15,%01110001 + !byte $13,%01110001 + !byte $11,%10010001 + !byte $0F,%10010001 + !byte $0D,%10110001 + !byte $0B,%10110001 + !byte $09,%10110001 + !byte $07,%10110001 + !byte $05,%10110001 + !byte $03,%10110001 + !byte $01,%10110001 + !byte $5F,%00101000 + !byte $5F,%01001000 + !byte $5D,%10101000 + !byte $5D,%11001000 + !byte $5B,%01001001 + !byte $5B,%01101001 + !byte $59,%10101001 + !byte $59,%11001001 + !byte $57,%01001010 + !byte $57,%01101010 + !byte $55,%10101010 + !byte $55,%11001010 + !byte $53,%00101011 + !byte $53,%01001011 + !byte $51,%10001011 + !byte $4F,%11001011 + !byte $4F,%00001100 + !byte $4D,%01001100 + !byte $4B,%10001100 + !byte $49,%11001100 + !byte $49,%00001101 + !byte $47,%00101101 + !byte $45,%01101101 + !byte $45,%10001101 + !byte $43,%10101101 + !byte $43,%11001101 + !byte $41,%00001110 + !byte $3F,%01001110 + !byte $3D,%01101110 + !byte $3D,%10001110 + !byte $3B,%10101110 + !byte $39,%11001110 + !byte $37,%00101111 + !byte $35,%01001111 + !byte $33,%01101111 + !byte $33,%10001111 + !byte $31,%10101111 + !byte $2F,%11001111 + !byte $2D,%00010000 + !byte $2B,%00110000 + !byte $29,%01010000 + !byte $27,%01110000 + !byte $25,%10010000 + !byte $23,%10110000 + !byte $21,%10110000 + !byte $1F,%11010000 + !byte $1D,%00010001 + !byte $1B,%00010001 + !byte $19,%00110001 + !byte $17,%00110001 + !byte $17,%01010001 + !byte $15,%01010001 + !byte $13,%01010001 + !byte $11,%01110001 + !byte $0F,%01110001 + !byte $0D,%10010001 + !byte $0B,%10010001 + !byte $09,%10010001 + !byte $07,%10010001 + !byte $05,%10010001 + !byte $03,%10010001 + !byte $01,%10010001 + !byte $5F,%11000111 + !byte $5F,%00001000 + !byte $5D,%01101000 + !byte $5D,%10001000 + !byte $5B,%00001001 + !byte $5B,%00101001 + !byte $59,%10001001 + !byte $57,%00001010 + !byte $57,%00101010 + !byte $55,%01101010 + !byte $55,%10001010 + !byte $53,%11001010 + !byte $53,%00001011 + !byte $51,%01001011 + !byte $51,%01101011 + !byte $4F,%10101011 + !byte $4D,%00001100 + !byte $4D,%00101100 + !byte $4B,%01001100 + !byte $4B,%01101100 + !byte $49,%10101100 + !byte $47,%00001101 + !byte $45,%01001101 + !byte $43,%10001101 + !byte $41,%11001101 + !byte $3F,%00001110 + !byte $3F,%00101110 + !byte $3D,%01001110 + !byte $3B,%10001110 + !byte $39,%10101110 + !byte $37,%00001111 + !byte $35,%00101111 + !byte $33,%01001111 + !byte $31,%10001111 + !byte $2F,%10101111 + !byte $2D,%11001111 + !byte $2B,%00010000 + !byte $29,%00110000 + !byte $27,%01010000 + !byte $25,%01110000 + !byte $23,%10010000 + !byte $21,%10010000 + !byte $1F,%10110000 + !byte $1D,%11010000 + !byte $1B,%11010000 + !byte $19,%00010001 + !byte $17,%00010001 + !byte $15,%00110001 + !byte $13,%00110001 + !byte $11,%01010001 + !byte $0F,%01010001 + !byte $0D,%01010001 + !byte $0D,%01110001 + !byte $0B,%01110001 + !byte $09,%01110001 + !byte $07,%01110001 + !byte $05,%01110001 + !byte $03,%01110001 + !byte $01,%01110001 + !byte $5F,%01100111 + !byte $5F,%10000111 + !byte $5F,%10100111 + !byte $5D,%00101000 + !byte $5D,%01001000 + !byte $5B,%10101000 + !byte $5B,%11001000 + !byte $59,%01001001 + !byte $59,%01101001 + !byte $57,%10101001 + !byte $57,%11001001 + !byte $55,%01001010 + !byte $53,%10101010 + !byte $51,%00101011 + !byte $4F,%01101011 + !byte $4F,%10001011 + !byte $4D,%11001011 + !byte $4B,%00101100 + !byte $49,%01101100 + !byte $49,%10001100 + !byte $47,%11001100 + !byte $45,%00101101 + !byte $43,%01001101 + !byte $43,%01101101 + !byte $41,%10001101 + !byte $41,%10101101 + !byte $3F,%11001101 + !byte $3D,%00101110 + !byte $3B,%01001110 + !byte $3B,%01101110 + !byte $39,%10001110 + !byte $37,%10101110 + !byte $37,%11001110 + !byte $35,%00001111 + !byte $33,%00101111 + !byte $31,%01001111 + !byte $31,%01101111 + !byte $2F,%10001111 + !byte $2D,%10101111 + !byte $2B,%11001111 + !byte $29,%00010000 + !byte $27,%00110000 + !byte $25,%01010000 + !byte $23,%01010000 + !byte $23,%01110000 + !byte $21,%01110000 + !byte $1F,%10010000 + !byte $1D,%10110000 + !byte $1B,%10110000 + !byte $19,%11010000 + !byte $17,%11010000 + !byte $15,%00010001 + !byte $13,%00010001 + !byte $11,%00110001 + !byte $0F,%00110001 + !byte $0D,%00110001 + !byte $0B,%01010001 + !byte $09,%01010001 + !byte $07,%01010001 + !byte $05,%01010001 + !byte $03,%01010001 + !byte $01,%01010001 + !byte $5F,%00100111 + !byte $5F,%01000111 + !byte $5D,%11000111 + !byte $5D,%00001000 + !byte $5B,%01101000 + !byte $5B,%10001000 + !byte $59,%00001001 + !byte $59,%00101001 + !byte $57,%10001001 + !byte $55,%00001010 + !byte $55,%00101010 + !byte $53,%01101010 + !byte $53,%10001010 + !byte $51,%11001010 + !byte $51,%00001011 + !byte $4F,%01001011 + !byte $4D,%10001011 + !byte $4D,%10101011 + !byte $4B,%00001100 + !byte $49,%01001100 + !byte $47,%10001100 + !byte $47,%10101100 + !byte $45,%11001100 + !byte $45,%00001101 + !byte $43,%00101101 + !byte $41,%01101101 + !byte $3F,%10101101 + !byte $3D,%00001110 + !byte $3B,%00101110 + !byte $39,%01101110 + !byte $37,%10001110 + !byte $35,%11001110 + !byte $33,%00001111 + !byte $31,%00101111 + !byte $2F,%01001111 + !byte $2F,%01101111 + !byte $2D,%10001111 + !byte $2B,%10101111 + !byte $29,%11001111 + !byte $27,%00010000 + !byte $25,%00110000 + !byte $23,%00110000 + !byte $21,%01010000 + !byte $1F,%01110000 + !byte $1D,%10010000 + !byte $1B,%10010000 + !byte $19,%10110000 + !byte $17,%10110000 + !byte $15,%11010000 + !byte $13,%11010000 + !byte $11,%00010001 + !byte $0F,%00010001 + !byte $0D,%00010001 + !byte $0B,%00110001 + !byte $09,%00110001 + !byte $07,%00110001 + !byte $05,%00110001 + !byte $03,%00110001 + !byte $01,%00110001 + !byte $5F,%11000110 + !byte $5F,%00000111 + !byte $5D,%01100111 + !byte $5D,%10000111 + !byte $5D,%10100111 + !byte $5B,%00101000 + !byte $5B,%01001000 + !byte $59,%10101000 + !byte $59,%11001000 + !byte $57,%01001001 + !byte $57,%01101001 + !byte $55,%10101001 + !byte $55,%11001001 + !byte $53,%00101010 + !byte $53,%01001010 + !byte $51,%10001010 + !byte $51,%10101010 + !byte $4F,%00001011 + !byte $4F,%00101011 + !byte $4D,%01101011 + !byte $4B,%10101011 + !byte $4B,%11001011 + !byte $49,%00101100 + !byte $47,%01101100 + !byte $45,%10101100 + !byte $43,%00001101 + !byte $41,%01001101 + !byte $3F,%10001101 + !byte $3D,%10101101 + !byte $3D,%11001101 + !byte $3B,%00001110 + !byte $39,%01001110 + !byte $37,%01101110 + !byte $35,%10001110 + !byte $35,%10101110 + !byte $33,%11001110 + !byte $31,%00001111 + !byte $2F,%00101111 + !byte $2D,%01001111 + !byte $2D,%01101111 + !byte $2B,%10001111 + !byte $29,%10101111 + !byte $27,%11001111 + !byte $25,%11001111 + !byte $25,%00010000 + !byte $23,%00010000 + !byte $21,%00110000 + !byte $1F,%01010000 + !byte $1D,%01110000 + !byte $1B,%01110000 + !byte $19,%10010000 + !byte $17,%10010000 + !byte $15,%10110000 + !byte $13,%10110000 + !byte $11,%11010000 + !byte $0F,%11010000 + !byte $0D,%11010000 + !byte $0B,%00010001 + !byte $09,%00010001 + !byte $07,%00010001 + !byte $05,%00010001 + !byte $03,%00010001 + !byte $01,%00010001 + !byte $5F,%01100110 + !byte $5F,%10000110 + !byte $5F,%10100110 + !byte $5D,%00100111 + !byte $5D,%01000111 + !byte $5B,%11000111 + !byte $5B,%00001000 + !byte $59,%01101000 + !byte $59,%10001000 + !byte $57,%00001001 + !byte $57,%00101001 + !byte $55,%01101001 + !byte $55,%10001001 + !byte $53,%00001010 + !byte $51,%01101010 + !byte $4F,%11001010 + !byte $4D,%00101011 + !byte $4D,%01001011 + !byte $4B,%10001011 + !byte $49,%11001011 + !byte $49,%00001100 + !byte $47,%00101100 + !byte $47,%01001100 + !byte $45,%10001100 + !byte $43,%11001100 + !byte $41,%00001101 + !byte $41,%00101101 + !byte $3F,%01001101 + !byte $3F,%01101101 + !byte $3D,%10001101 + !byte $3B,%11001101 + !byte $39,%00001110 + !byte $39,%00101110 + !byte $37,%01001110 + !byte $35,%01101110 + !byte $33,%10101110 + !byte $31,%11001110 + !byte $2F,%00001111 + !byte $2D,%00101111 + !byte $2B,%01001111 + !byte $2B,%01101111 + !byte $29,%10001111 + !byte $27,%10001111 + !byte $27,%10101111 + !byte $25,%10101111 + !byte $23,%11001111 + !byte $21,%00010000 + !byte $1F,%00110000 + !byte $1D,%01010000 + !byte $1B,%01010000 + !byte $19,%01110000 + !byte $17,%01110000 + !byte $15,%10010000 + !byte $13,%10010000 + !byte $11,%10110000 + !byte $0F,%10110000 + !byte $0D,%10110000 + !byte $0B,%11010000 + !byte $09,%11010000 + !byte $07,%11010000 + !byte $05,%11010000 + !byte $03,%11010000 + !byte $01,%11010000 + !byte $5F,%00000110 + !byte $5F,%00100110 + !byte $5F,%01000110 + !byte $5D,%11000110 + !byte $5D,%00000111 + !byte $5B,%10000111 + !byte $5B,%10100111 + !byte $59,%00101000 + !byte $59,%01001000 + !byte $57,%10101000 + !byte $57,%11001000 + !byte $55,%01001001 + !byte $53,%10101001 + !byte $53,%11001001 + !byte $51,%00101010 + !byte $51,%01001010 + !byte $4F,%10001010 + !byte $4F,%10101010 + !byte $4D,%00001011 + !byte $4B,%01001011 + !byte $4B,%01101011 + !byte $49,%10101011 + !byte $47,%00001100 + !byte $45,%01001100 + !byte $45,%01101100 + !byte $43,%10001100 + !byte $43,%10101100 + !byte $41,%11001100 + !byte $3F,%00101101 + !byte $3D,%01101101 + !byte $3B,%10101101 + !byte $39,%11001101 + !byte $37,%00101110 + !byte $35,%01001110 + !byte $33,%10001110 + !byte $31,%10101110 + !byte $2F,%11001110 + !byte $2D,%00001111 + !byte $2B,%00101111 + !byte $29,%01001111 + !byte $29,%01101111 + !byte $27,%01101111 + !byte $25,%10001111 + !byte $23,%10101111 + !byte $21,%11001111 + !byte $1F,%00010000 + !byte $1D,%00110000 + !byte $1B,%00110000 + !byte $19,%01010000 + !byte $17,%01010000 + !byte $15,%01110000 + !byte $13,%01110000 + !byte $11,%10010000 + !byte $0F,%10010000 + !byte $0D,%10010000 + !byte $0B,%10110000 + !byte $09,%10110000 + !byte $07,%10110000 + !byte $05,%10110000 + !byte $03,%10110000 + !byte $01,%10110000 + !byte $5F,%10100101 + !byte $5F,%11000101 + !byte $5D,%01100110 + !byte $5D,%10000110 + !byte $5D,%10100110 + !byte $5B,%00100111 + !byte $5B,%01000111 + !byte $5B,%01100111 + !byte $59,%11000111 + !byte $59,%00001000 + !byte $57,%01101000 + !byte $57,%10001000 + !byte $55,%00001001 + !byte $55,%00101001 + !byte $53,%01101001 + !byte $53,%10001001 + !byte $51,%11001001 + !byte $51,%00001010 + !byte $4F,%01001010 + !byte $4F,%01101010 + !byte $4D,%10101010 + !byte $4D,%11001010 + !byte $4B,%00101011 + !byte $49,%01101011 + !byte $49,%10001011 + !byte $47,%11001011 + !byte $45,%00101100 + !byte $43,%01101100 + !byte $41,%10101100 + !byte $3F,%00001101 + !byte $3D,%01001101 + !byte $3B,%01101101 + !byte $3B,%10001101 + !byte $39,%10101101 + !byte $37,%11001101 + !byte $37,%00001110 + !byte $35,%00101110 + !byte $33,%01001110 + !byte $33,%01101110 + !byte $31,%10001110 + !byte $2F,%10101110 + !byte $2D,%11001110 + !byte $2B,%00001111 + !byte $29,%00101111 + !byte $27,%01001111 + !byte $25,%01101111 + !byte $23,%10001111 + !byte $21,%10101111 + !byte $1F,%11001111 + !byte $1D,%00010000 + !byte $1B,%00010000 + !byte $19,%00110000 + !byte $17,%00110000 + !byte $15,%01010000 + !byte $13,%01010000 + !byte $11,%01110000 + !byte $0F,%01110000 + !byte $0D,%01110000 + !byte $0B,%10010000 + !byte $09,%10010000 + !byte $07,%10010000 + !byte $05,%10010000 + !byte $03,%10010000 + !byte $01,%10010000 + !byte $5F,%00100101 + !byte $5F,%01000101 + !byte $5F,%01100101 + !byte $5F,%10000101 + !byte $5D,%00100110 + !byte $5D,%01000110 + !byte $5B,%11000110 + !byte $5B,%00000111 + !byte $59,%10000111 + !byte $59,%10100111 + !byte $57,%00101000 + !byte $57,%01001000 + !byte $55,%10101000 + !byte $55,%11001000 + !byte $53,%00101001 + !byte $53,%01001001 + !byte $51,%10101001 + !byte $4F,%00101010 + !byte $4D,%10001010 + !byte $4B,%11001010 + !byte $4B,%00001011 + !byte $49,%01001011 + !byte $47,%10001011 + !byte $47,%10101011 + !byte $45,%11001011 + !byte $45,%00001100 + !byte $43,%01001100 + !byte $41,%10001100 + !byte $3F,%11001100 + !byte $3D,%00001101 + !byte $3D,%00101101 + !byte $3B,%01001101 + !byte $39,%10001101 + !byte $37,%10101101 + !byte $35,%00001110 + !byte $33,%00101110 + !byte $31,%01101110 + !byte $2F,%10001110 + !byte $2D,%10101110 + !byte $2B,%11001110 + !byte $29,%00001111 + !byte $27,%00101111 + !byte $25,%01001111 + !byte $23,%01101111 + !byte $21,%10001111 + !byte $1F,%10101111 + !byte $1D,%10101111 + !byte $1D,%11001111 + !byte $1B,%11001111 + !byte $19,%00010000 + !byte $17,%00010000 + !byte $15,%00110000 + !byte $13,%00110000 + !byte $11,%01010000 + !byte $0F,%01010000 + !byte $0D,%01010000 + !byte $0B,%01110000 + !byte $09,%01110000 + !byte $07,%01110000 + !byte $05,%01110000 + !byte $03,%01110000 + !byte $01,%01110000 + !byte $5F,%10100100 + !byte $5F,%11000100 + !byte $5F,%00000101 + !byte $5D,%10100101 + !byte $5D,%11000101 + !byte $5D,%00000110 + !byte $5B,%10000110 + !byte $5B,%10100110 + !byte $59,%01000111 + !byte $59,%01100111 + !byte $57,%11000111 + !byte $57,%00001000 + !byte $55,%01101000 + !byte $55,%10001000 + !byte $53,%00001001 + !byte $51,%01101001 + !byte $51,%10001001 + !byte $4F,%11001001 + !byte $4F,%00001010 + !byte $4D,%01001010 + !byte $4D,%01101010 + !byte $4B,%10101010 + !byte $49,%00001011 + !byte $49,%00101011 + !byte $47,%01101011 + !byte $45,%10101011 + !byte $43,%00001100 + !byte $43,%00101100 + !byte $41,%01001100 + !byte $41,%01101100 + !byte $3F,%10001100 + !byte $3F,%10101100 + !byte $3D,%11001100 + !byte $3B,%00101101 + !byte $39,%01101101 + !byte $37,%10001101 + !byte $35,%11001101 + !byte $33,%00001110 + !byte $31,%00101110 + !byte $31,%01001110 + !byte $2F,%01101110 + !byte $2D,%10001110 + !byte $2B,%10101110 + !byte $29,%11001110 + !byte $27,%00001111 + !byte $25,%00101111 + !byte $23,%01001111 + !byte $21,%01101111 + !byte $1F,%10001111 + !byte $1D,%10001111 + !byte $1B,%10101111 + !byte $19,%11001111 + !byte $17,%11001111 + !byte $15,%00010000 + !byte $13,%00010000 + !byte $11,%00110000 + !byte $0F,%00110000 + !byte $0D,%00110000 + !byte $0B,%01010000 + !byte $09,%01010000 + !byte $07,%01010000 + !byte $05,%01010000 + !byte $03,%01010000 + !byte $01,%01010000 + !byte $5F,%00100100 + !byte $5F,%01000100 + !byte $5F,%01100100 + !byte $5F,%10000100 + !byte $5D,%01000101 + !byte $5D,%01100101 + !byte $5D,%10000101 + !byte $5B,%00100110 + !byte $5B,%01000110 + !byte $5B,%01100110 + !byte $59,%11000110 + !byte $59,%00000111 + !byte $59,%00100111 + !byte $57,%10000111 + !byte $57,%10100111 + !byte $55,%00101000 + !byte $55,%01001000 + !byte $53,%10101000 + !byte $53,%11001000 + !byte $51,%00101001 + !byte $51,%01001001 + !byte $4F,%10001001 + !byte $4F,%10101001 + !byte $4D,%00001010 + !byte $4D,%00101010 + !byte $4B,%01101010 + !byte $4B,%10001010 + !byte $49,%11001010 + !byte $47,%00101011 + !byte $47,%01001011 + !byte $45,%10001011 + !byte $43,%11001011 + !byte $41,%00101100 + !byte $3F,%01101100 + !byte $3D,%10101100 + !byte $3B,%00001101 + !byte $39,%00101101 + !byte $39,%01001101 + !byte $37,%01101101 + !byte $35,%10001101 + !byte $35,%10101101 + !byte $33,%11001101 + !byte $31,%00001110 + !byte $2F,%01001110 + !byte $2D,%01101110 + !byte $2B,%10001110 + !byte $29,%10101110 + !byte $27,%11001110 + !byte $25,%00001111 + !byte $23,%00101111 + !byte $21,%01001111 + !byte $1F,%01101111 + !byte $1D,%01101111 + !byte $1B,%10001111 + !byte $19,%10101111 + !byte $17,%10101111 + !byte $15,%11001111 + !byte $13,%11001111 + !byte $11,%00010000 + !byte $0F,%00010000 + !byte $0D,%00010000 + !byte $0B,%00110000 + !byte $09,%00110000 + !byte $07,%00110000 + !byte $05,%00110000 + !byte $03,%00110000 + !byte $01,%00110000 + !byte $5F,%10000011 + !byte $5F,%10100011 + !byte $5F,%11000011 + !byte $5F,%00000100 + !byte $5D,%11000100 + !byte $5D,%00000101 + !byte $5D,%00100101 + !byte $5B,%10100101 + !byte $5B,%11000101 + !byte $5B,%00000110 + !byte $59,%10000110 + !byte $59,%10100110 + !byte $57,%01000111 + !byte $57,%01100111 + !byte $55,%11000111 + !byte $55,%00001000 + !byte $53,%01101000 + !byte $53,%10001000 + !byte $51,%11001000 + !byte $51,%00001001 + !byte $4F,%01101001 + !byte $4D,%11001001 + !byte $4B,%01001010 + !byte $49,%10001010 + !byte $49,%10101010 + !byte $47,%00001011 + !byte $45,%01001011 + !byte $45,%01101011 + !byte $43,%10101011 + !byte $41,%00001100 + !byte $3F,%01001100 + !byte $3D,%10001100 + !byte $3B,%10101100 + !byte $3B,%11001100 + !byte $39,%00001101 + !byte $37,%01001101 + !byte $35,%01101101 + !byte $33,%10101101 + !byte $31,%11001101 + !byte $2F,%00001110 + !byte $2F,%00101110 + !byte $2D,%01001110 + !byte $2B,%01101110 + !byte $29,%10001110 + !byte $27,%10101110 + !byte $25,%11001110 + !byte $23,%00001111 + !byte $21,%00101111 + !byte $1F,%01001111 + !byte $1D,%01001111 + !byte $1B,%01101111 + !byte $19,%10001111 + !byte $17,%10001111 + !byte $15,%10101111 + !byte $13,%10101111 + !byte $11,%11001111 + !byte $0F,%11001111 + !byte $0D,%11001111 + !byte $0B,%00010000 + !byte $09,%00010000 + !byte $07,%00010000 + !byte $05,%00010000 + !byte $03,%00010000 + !byte $01,%00010000 + !byte $5F,%11000010 + !byte $5F,%00000011 + !byte $5F,%00100011 + !byte $5F,%01000011 + !byte $5F,%01100011 + !byte $5D,%01000100 + !byte $5D,%01100100 + !byte $5D,%10000100 + !byte $5D,%10100100 + !byte $5B,%01000101 + !byte $5B,%01100101 + !byte $5B,%10000101 + !byte $59,%00100110 + !byte $59,%01000110 + !byte $59,%01100110 + !byte $57,%11000110 + !byte $57,%00000111 + !byte $57,%00100111 + !byte $55,%10000111 + !byte $55,%10100111 + !byte $53,%00101000 + !byte $53,%01001000 + !byte $51,%10101000 + !byte $4F,%00101001 + !byte $4F,%01001001 + !byte $4D,%10001001 + !byte $4D,%10101001 + !byte $4B,%00001010 + !byte $4B,%00101010 + !byte $49,%01101010 + !byte $47,%10101010 + !byte $47,%11001010 + !byte $45,%00101011 + !byte $43,%01101011 + !byte $43,%10001011 + !byte $41,%10101011 + !byte $41,%11001011 + !byte $3F,%00001100 + !byte $3F,%00101100 + !byte $3D,%01001100 + !byte $3D,%01101100 + !byte $3B,%10001100 + !byte $39,%11001100 + !byte $37,%00001101 + !byte $37,%00101101 + !byte $35,%01001101 + !byte $33,%01101101 + !byte $33,%10001101 + !byte $31,%10101101 + !byte $2F,%11001101 + !byte $2D,%00101110 + !byte $2B,%01001110 + !byte $29,%01101110 + !byte $27,%10001110 + !byte $25,%10101110 + !byte $23,%11001110 + !byte $21,%00001111 + !byte $1F,%00001111 + !byte $1F,%00101111 + !byte $1D,%00101111 + !byte $1B,%01001111 + !byte $19,%01101111 + !byte $17,%01101111 + !byte $15,%10001111 + !byte $13,%10001111 + !byte $11,%10101111 + !byte $0F,%10101111 + !byte $0D,%10101111 + !byte $0B,%11001111 + !byte $09,%11001111 + !byte $07,%11001111 + !byte $05,%11001111 + !byte $03,%11001111 + !byte $01,%11001111 + !byte $5F,%00000010 + !byte $5F,%00100010 + !byte $5F,%01000010 + !byte $5F,%01100010 + !byte $5F,%10000010 + !byte $5F,%10100010 + !byte $5D,%10100011 + !byte $5D,%11000011 + !byte $5D,%00000100 + !byte $5D,%00100100 + !byte $5B,%11000100 + !byte $5B,%00000101 + !byte $5B,%00100101 + !byte $59,%11000101 + !byte $59,%00000110 + !byte $57,%10000110 + !byte $57,%10100110 + !byte $55,%01000111 + !byte $55,%01100111 + !byte $53,%11000111 + !byte $53,%00001000 + !byte $51,%01101000 + !byte $51,%10001000 + !byte $4F,%11001000 + !byte $4F,%00001001 + !byte $4D,%01101001 + !byte $4B,%11001001 + !byte $49,%00101010 + !byte $49,%01001010 + !byte $47,%10001010 + !byte $45,%11001010 + !byte $45,%00001011 + !byte $43,%01001011 + !byte $41,%10001011 + !byte $3F,%11001011 + !byte $3D,%00101100 + !byte $3B,%01101100 + !byte $39,%10101100 + !byte $37,%11001100 + !byte $35,%00101101 + !byte $33,%01001101 + !byte $31,%10001101 + !byte $2F,%10101101 + !byte $2D,%11001101 + !byte $2D,%00001110 + !byte $2B,%00101110 + !byte $29,%01001110 + !byte $27,%01101110 + !byte $25,%10001110 + !byte $23,%10101110 + !byte $21,%11001110 + !byte $1F,%11001110 + !byte $1D,%00001111 + !byte $1B,%00101111 + !byte $19,%01001111 + !byte $17,%01001111 + !byte $15,%01101111 + !byte $13,%01101111 + !byte $11,%10001111 + !byte $0F,%10001111 + !byte $0D,%10001111 + !byte $0B,%10101111 + !byte $09,%10101111 + !byte $07,%10101111 + !byte $05,%10101111 + !byte $03,%10101111 + !byte $01,%10101111 + !byte $5F,%00000000 + !byte $5F,%00100000 + !byte $5F,%01000000 + !byte $5F,%01100000 + !byte $5F,%10000000 + !byte $5F,%10100000 + !byte $5F,%11000000 + !byte $5F,%00000001 + !byte $5F,%00100001 + !byte $5F,%01000001 + !byte $5F,%01100001 + !byte $5F,%10000001 + !byte $5F,%10100001 + !byte $5F,%11000001 + !byte $5D,%00100011 + !byte $5D,%01000011 + !byte $5D,%01100011 + !byte $5D,%10000011 + !byte $5B,%01100100 + !byte $5B,%10000100 + !byte $5B,%10100100 + !byte $59,%01100101 + !byte $59,%10000101 + !byte $59,%10100101 + !byte $57,%01000110 + !byte $57,%01100110 + !byte $55,%00000111 + !byte $55,%00100111 + !byte $53,%10000111 + !byte $53,%10100111 + !byte $51,%00101000 + !byte $51,%01001000 + !byte $4F,%10001000 + !byte $4F,%10101000 + !byte $4D,%00101001 + !byte $4D,%01001001 + !byte $4B,%10001001 + !byte $4B,%10101001 + !byte $49,%00001010 + !byte $47,%01001010 + !byte $47,%01101010 + !byte $45,%10101010 + !byte $43,%00001011 + !byte $43,%00101011 + !byte $41,%01101011 + !byte $3F,%10101011 + !byte $3D,%00001100 + !byte $3B,%01001100 + !byte $39,%01101100 + !byte $39,%10001100 + !byte $37,%10101100 + !byte $35,%00001101 + !byte $33,%00101101 + !byte $31,%01101101 + !byte $2F,%10001101 + !byte $2D,%10101101 + !byte $2B,%11001101 + !byte $2B,%00001110 + !byte $29,%00101110 + !byte $27,%01001110 + !byte $25,%01101110 + !byte $23,%10001110 + !byte $21,%10101110 + !byte $1F,%10101110 + !byte $1D,%11001110 + !byte $1B,%00001111 + !byte $19,%00101111 + !byte $17,%00101111 + !byte $15,%01001111 + !byte $13,%01001111 + !byte $11,%01101111 + !byte $0F,%01101111 + !byte $0D,%01101111 + !byte $0B,%10001111 + !byte $09,%10001111 + !byte $07,%10001111 + !byte $05,%10001111 + !byte $03,%10001111 + !byte $01,%10001111 + !byte $5D,%01000010 + !byte $5D,%01100010 + !byte $5D,%10000010 + !byte $5D,%10100010 + !byte $5D,%11000010 + !byte $5D,%00000011 + !byte $5B,%11000011 + !byte $5B,%00000100 + !byte $5B,%00100100 + !byte $5B,%01000100 + !byte $59,%00000101 + !byte $59,%00100101 + !byte $59,%01000101 + !byte $57,%11000101 + !byte $57,%00000110 + !byte $57,%00100110 + !byte $55,%10000110 + !byte $55,%10100110 + !byte $55,%11000110 + !byte $53,%01000111 + !byte $53,%01100111 + !byte $51,%11000111 + !byte $51,%00001000 + !byte $4F,%01101000 + !byte $4D,%11001000 + !byte $4D,%00001001 + !byte $4B,%01001001 + !byte $4B,%01101001 + !byte $49,%10101001 + !byte $49,%11001001 + !byte $47,%00101010 + !byte $45,%01101010 + !byte $45,%10001010 + !byte $43,%11001010 + !byte $41,%00101011 + !byte $41,%01001011 + !byte $3F,%01101011 + !byte $3F,%10001011 + !byte $3D,%10101011 + !byte $3D,%11001011 + !byte $3B,%00001100 + !byte $3B,%00101100 + !byte $39,%01001100 + !byte $37,%10001100 + !byte $35,%10101100 + !byte $35,%11001100 + !byte $33,%00001101 + !byte $31,%00101101 + !byte $31,%01001101 + !byte $2F,%01101101 + !byte $2D,%10001101 + !byte $2B,%10101101 + !byte $29,%11001101 + !byte $29,%00001110 + !byte $27,%00101110 + !byte $25,%01001110 + !byte $23,%01101110 + !byte $21,%01101110 + !byte $21,%10001110 + !byte $1F,%10001110 + !byte $1D,%10101110 + !byte $1B,%11001110 + !byte $19,%00001111 + !byte $17,%00001111 + !byte $15,%00101111 + !byte $13,%00101111 + !byte $11,%01001111 + !byte $0F,%01001111 + !byte $0D,%01001111 + !byte $0B,%01101111 + !byte $09,%01101111 + !byte $07,%01101111 + !byte $05,%01101111 + !byte $03,%01101111 + !byte $01,%01101111 + !byte $5D,%00000001 + !byte $5D,%00100001 + !byte $5D,%01000001 + !byte $5D,%01100001 + !byte $5D,%10000001 + !byte $5D,%10100001 + !byte $5D,%11000001 + !byte $5D,%00000010 + !byte $5D,%00100010 + !byte $5B,%01000011 + !byte $5B,%01100011 + !byte $5B,%10000011 + !byte $5B,%10100011 + !byte $59,%10000100 + !byte $59,%10100100 + !byte $59,%11000100 + !byte $57,%01100101 + !byte $57,%10000101 + !byte $57,%10100101 + !byte $55,%01000110 + !byte $55,%01100110 + !byte $53,%00000111 + !byte $53,%00100111 + !byte $51,%10000111 + !byte $51,%10100111 + !byte $4F,%00101000 + !byte $4F,%01001000 + !byte $4D,%10001000 + !byte $4D,%10101000 + !byte $4B,%00101001 + !byte $49,%10001001 + !byte $47,%00001010 + !byte $45,%01001010 + !byte $43,%10001010 + !byte $43,%10101010 + !byte $41,%00001011 + !byte $3F,%01001011 + !byte $3D,%10001011 + !byte $3B,%11001011 + !byte $39,%00101100 + !byte $37,%01101100 + !byte $35,%10001100 + !byte $33,%11001100 + !byte $31,%00001101 + !byte $2F,%01001101 + !byte $2D,%01101101 + !byte $2B,%10001101 + !byte $29,%10101101 + !byte $27,%11001101 + !byte $27,%00001110 + !byte $25,%00101110 + !byte $23,%00101110 + !byte $23,%01001110 + !byte $21,%01001110 + !byte $1F,%01101110 + !byte $1D,%10001110 + !byte $1B,%10101110 + !byte $19,%10101110 + !byte $19,%11001110 + !byte $17,%11001110 + !byte $15,%00001111 + !byte $13,%00001111 + !byte $11,%00101111 + !byte $0F,%00101111 + !byte $0D,%00101111 + !byte $0B,%01001111 + !byte $09,%01001111 + !byte $07,%01001111 + !byte $05,%01001111 + !byte $03,%01001111 + !byte $01,%01001111 + !byte $5D,%00000000 + !byte $5D,%00100000 + !byte $5D,%01000000 + !byte $5D,%01100000 + !byte $5D,%10000000 + !byte $5D,%10100000 + !byte $5D,%11000000 + !byte $5B,%10000010 + !byte $5B,%10100010 + !byte $5B,%11000010 + !byte $5B,%00000011 + !byte $5B,%00100011 + !byte $59,%00000100 + !byte $59,%00100100 + !byte $59,%01000100 + !byte $59,%01100100 + !byte $57,%00100101 + !byte $57,%01000101 + !byte $55,%11000101 + !byte $55,%00000110 + !byte $55,%00100110 + !byte $53,%10000110 + !byte $53,%10100110 + !byte $53,%11000110 + !byte $51,%01000111 + !byte $51,%01100111 + !byte $4F,%11000111 + !byte $4F,%00001000 + !byte $4D,%01101000 + !byte $4B,%11001000 + !byte $4B,%00001001 + !byte $49,%01001001 + !byte $49,%01101001 + !byte $47,%10101001 + !byte $47,%11001001 + !byte $45,%00101010 + !byte $43,%01101010 + !byte $41,%10101010 + !byte $41,%11001010 + !byte $3F,%00101011 + !byte $3D,%01101011 + !byte $3B,%10101011 + !byte $39,%00001100 + !byte $37,%00101100 + !byte $37,%01001100 + !byte $35,%01101100 + !byte $33,%10101100 + !byte $31,%11001100 + !byte $2F,%00101101 + !byte $2D,%01001101 + !byte $2B,%01101101 + !byte $29,%10001101 + !byte $27,%10101101 + !byte $25,%11001101 + !byte $25,%00001110 + !byte $23,%00001110 + !byte $21,%00101110 + !byte $1F,%01001110 + !byte $1D,%01101110 + !byte $1B,%10001110 + !byte $19,%10001110 + !byte $17,%10101110 + !byte $15,%11001110 + !byte $13,%11001110 + !byte $11,%00001111 + !byte $0F,%00001111 + !byte $0D,%00001111 + !byte $0B,%00101111 + !byte $09,%00101111 + !byte $07,%00101111 + !byte $05,%00101111 + !byte $03,%00101111 + !byte $01,%00101111 + !byte $5B,%10000001 + !byte $5B,%10100001 + !byte $5B,%11000001 + !byte $5B,%00000010 + !byte $5B,%00100010 + !byte $5B,%01000010 + !byte $5B,%01100010 + !byte $59,%01100011 + !byte $59,%10000011 + !byte $59,%10100011 + !byte $59,%11000011 + !byte $57,%10000100 + !byte $57,%10100100 + !byte $57,%11000100 + !byte $57,%00000101 + !byte $55,%10000101 + !byte $55,%10100101 + !byte $53,%01000110 + !byte $53,%01100110 + !byte $51,%00000111 + !byte $51,%00100111 + !byte $4F,%10000111 + !byte $4F,%10100111 + !byte $4D,%00101000 + !byte $4D,%01001000 + !byte $4B,%10001000 + !byte $4B,%10101000 + !byte $49,%00001001 + !byte $49,%00101001 + !byte $47,%01101001 + !byte $47,%10001001 + !byte $45,%11001001 + !byte $45,%00001010 + !byte $43,%01001010 + !byte $41,%10001010 + !byte $3F,%11001010 + !byte $3F,%00001011 + !byte $3D,%00101011 + !byte $3D,%01001011 + !byte $3B,%01101011 + !byte $3B,%10001011 + !byte $39,%10101011 + !byte $39,%11001011 + !byte $37,%00001100 + !byte $35,%01001100 + !byte $33,%01101100 + !byte $33,%10001100 + !byte $31,%10101100 + !byte $2F,%11001100 + !byte $2F,%00001101 + !byte $2D,%00101101 + !byte $2B,%01001101 + !byte $29,%01101101 + !byte $27,%10001101 + !byte $25,%10101101 + !byte $23,%11001101 + !byte $21,%00001110 + !byte $1F,%00101110 + !byte $1D,%01001110 + !byte $1B,%01101110 + !byte $19,%01101110 + !byte $17,%10001110 + !byte $15,%10101110 + !byte $13,%10101110 + !byte $11,%11001110 + !byte $0F,%11001110 + !byte $0D,%11001110 + !byte $0B,%00001111 + !byte $09,%00001111 + !byte $07,%00001111 + !byte $05,%00001111 + !byte $03,%00001111 + !byte $01,%00001111 + !byte $5B,%00000000 + !byte $5B,%00100000 + !byte $5B,%01000000 + !byte $5B,%01100000 + !byte $5B,%10000000 + !byte $5B,%10100000 + !byte $5B,%11000000 + !byte $5B,%00000001 + !byte $5B,%00100001 + !byte $5B,%01000001 + !byte $5B,%01100001 + !byte $59,%11000010 + !byte $59,%00000011 + !byte $59,%00100011 + !byte $59,%01000011 + !byte $57,%00100100 + !byte $57,%01000100 + !byte $57,%01100100 + !byte $55,%00100101 + !byte $55,%01000101 + !byte $55,%01100101 + !byte $53,%00000110 + !byte $53,%00100110 + !byte $51,%10100110 + !byte $51,%11000110 + !byte $4F,%01000111 + !byte $4F,%01100111 + !byte $4D,%11000111 + !byte $4D,%00001000 + !byte $4B,%01001000 + !byte $4B,%01101000 + !byte $49,%11001000 + !byte $47,%01001001 + !byte $45,%10001001 + !byte $45,%10101001 + !byte $43,%00001010 + !byte $43,%00101010 + !byte $41,%01101010 + !byte $3F,%10101010 + !byte $3D,%00001011 + !byte $3B,%01001011 + !byte $39,%10001011 + !byte $37,%11001011 + !byte $35,%00101100 + !byte $33,%01001100 + !byte $31,%10001100 + !byte $2F,%10101100 + !byte $2D,%00001101 + !byte $2B,%00101101 + !byte $29,%01001101 + !byte $27,%01101101 + !byte $25,%10001101 + !byte $23,%10101101 + !byte $21,%11001101 + !byte $1F,%00001110 + !byte $1D,%00101110 + !byte $1B,%01001110 + !byte $19,%01001110 + !byte $17,%01101110 + !byte $15,%10001110 + !byte $13,%10001110 + !byte $11,%10101110 + !byte $0F,%10101110 + !byte $0D,%10101110 + !byte $0B,%11001110 + !byte $09,%11001110 + !byte $07,%11001110 + !byte $05,%11001110 + !byte $03,%11001110 + !byte $01,%11001110 + !byte $59,%11000001 + !byte $59,%00000010 + !byte $59,%00100010 + !byte $59,%01000010 + !byte $59,%01100010 + !byte $59,%10000010 + !byte $59,%10100010 + !byte $57,%10000011 + !byte $57,%10100011 + !byte $57,%11000011 + !byte $57,%00000100 + !byte $55,%10100100 + !byte $55,%11000100 + !byte $55,%00000101 + !byte $53,%10000101 + !byte $53,%10100101 + !byte $53,%11000101 + !byte $51,%01000110 + !byte $51,%01100110 + !byte $51,%10000110 + !byte $4F,%00000111 + !byte $4F,%00100111 + !byte $4D,%10000111 + !byte $4D,%10100111 + !byte $4B,%00101000 + !byte $49,%10001000 + !byte $49,%10101000 + !byte $47,%00001001 + !byte $47,%00101001 + !byte $45,%01101001 + !byte $43,%11001001 + !byte $41,%00101010 + !byte $41,%01001010 + !byte $3F,%01101010 + !byte $3F,%10001010 + !byte $3D,%11001010 + !byte $3B,%00101011 + !byte $39,%01101011 + !byte $37,%10001011 + !byte $37,%10101011 + !byte $35,%11001011 + !byte $35,%00001100 + !byte $33,%00101100 + !byte $31,%01001100 + !byte $31,%01101100 + !byte $2F,%10001100 + !byte $2D,%10101100 + !byte $2D,%11001100 + !byte $2B,%00001101 + !byte $29,%00101101 + !byte $27,%01001101 + !byte $25,%01101101 + !byte $23,%10001101 + !byte $21,%10101101 + !byte $1F,%11001101 + !byte $1D,%00001110 + !byte $1B,%00101110 + !byte $19,%00101110 + !byte $17,%01001110 + !byte $15,%01101110 + !byte $13,%01101110 + !byte $11,%10001110 + !byte $0F,%10001110 + !byte $0D,%10001110 + !byte $0B,%10101110 + !byte $09,%10101110 + !byte $07,%10101110 + !byte $05,%10101110 + !byte $03,%10101110 + !byte $01,%10101110 + !byte $59,%00000000 + !byte $59,%00100000 + !byte $59,%01000000 + !byte $59,%01100000 + !byte $59,%10000000 + !byte $59,%10100000 + !byte $59,%11000000 + !byte $59,%00000001 + !byte $59,%00100001 + !byte $59,%01000001 + !byte $59,%01100001 + !byte $59,%10000001 + !byte $59,%10100001 + !byte $57,%00000011 + !byte $57,%00100011 + !byte $57,%01000011 + !byte $57,%01100011 + !byte $55,%01000100 + !byte $55,%01100100 + !byte $55,%10000100 + !byte $53,%00100101 + !byte $53,%01000101 + !byte $53,%01100101 + !byte $51,%00000110 + !byte $51,%00100110 + !byte $4F,%10100110 + !byte $4F,%11000110 + !byte $4D,%01000111 + !byte $4D,%01100111 + !byte $4B,%11000111 + !byte $4B,%00001000 + !byte $49,%01001000 + !byte $49,%01101000 + !byte $47,%10101000 + !byte $47,%11001000 + !byte $45,%00101001 + !byte $45,%01001001 + !byte $43,%10001001 + !byte $43,%10101001 + !byte $41,%00001010 + !byte $3F,%01001010 + !byte $3D,%10001010 + !byte $3D,%10101010 + !byte $3B,%11001010 + !byte $3B,%00001011 + !byte $39,%00101011 + !byte $39,%01001011 + !byte $37,%01101011 + !byte $35,%10101011 + !byte $33,%00001100 + !byte $31,%00101100 + !byte $2F,%01101100 + !byte $2D,%10001100 + !byte $2B,%11001100 + !byte $29,%00001101 + !byte $27,%00101101 + !byte $25,%01001101 + !byte $23,%01101101 + !byte $21,%10001101 + !byte $1F,%10101101 + !byte $1D,%11001101 + !byte $1B,%00001110 + !byte $19,%00001110 + !byte $17,%00101110 + !byte $15,%01001110 + !byte $13,%01001110 + !byte $11,%01101110 + !byte $0F,%01101110 + !byte $0D,%01101110 + !byte $0B,%10001110 + !byte $09,%10001110 + !byte $07,%10001110 + !byte $05,%10001110 + !byte $03,%10001110 + !byte $01,%10001110 + !byte $57,%00100010 + !byte $57,%01000010 + !byte $57,%01100010 + !byte $57,%10000010 + !byte $57,%10100010 + !byte $57,%11000010 + !byte $55,%10100011 + !byte $55,%11000011 + !byte $55,%00000100 + !byte $55,%00100100 + !byte $53,%10100100 + !byte $53,%11000100 + !byte $53,%00000101 + !byte $51,%10000101 + !byte $51,%10100101 + !byte $51,%11000101 + !byte $4F,%01000110 + !byte $4F,%01100110 + !byte $4F,%10000110 + !byte $4D,%00000111 + !byte $4D,%00100111 + !byte $4B,%10000111 + !byte $4B,%10100111 + !byte $49,%00001000 + !byte $49,%00101000 + !byte $47,%10001000 + !byte $45,%00001001 + !byte $43,%01001001 + !byte $43,%01101001 + !byte $41,%10101001 + !byte $41,%11001001 + !byte $3F,%00101010 + !byte $3D,%01101010 + !byte $3B,%10101010 + !byte $39,%00001011 + !byte $37,%01001011 + !byte $35,%10001011 + !byte $33,%10101011 + !byte $33,%11001011 + !byte $31,%00001100 + !byte $2F,%01001100 + !byte $2D,%01101100 + !byte $2B,%10001100 + !byte $2B,%10101100 + !byte $29,%11001100 + !byte $27,%00001101 + !byte $25,%00101101 + !byte $23,%01001101 + !byte $21,%01101101 + !byte $1F,%10001101 + !byte $1D,%10101101 + !byte $1B,%10101101 + !byte $1B,%11001101 + !byte $19,%11001101 + !byte $17,%00001110 + !byte $15,%00001110 + !byte $15,%00101110 + !byte $13,%00101110 + !byte $11,%01001110 + !byte $0F,%01001110 + !byte $0D,%01001110 + !byte $0B,%01101110 + !byte $09,%01101110 + !byte $07,%01101110 + !byte $05,%01101110 + !byte $03,%01101110 + !byte $01,%01101110 + !byte $57,%11000000 + !byte $57,%00000001 + !byte $57,%00100001 + !byte $57,%01000001 + !byte $57,%01100001 + !byte $57,%10000001 + !byte $57,%10100001 + !byte $57,%11000001 + !byte $57,%00000010 + !byte $55,%00100011 + !byte $55,%01000011 + !byte $55,%01100011 + !byte $55,%10000011 + !byte $53,%01000100 + !byte $53,%01100100 + !byte $53,%10000100 + !byte $51,%01000101 + !byte $51,%01100101 + !byte $4F,%00000110 + !byte $4F,%00100110 + !byte $4D,%10100110 + !byte $4D,%11000110 + !byte $4B,%01000111 + !byte $4B,%01100111 + !byte $49,%11000111 + !byte $47,%01001000 + !byte $47,%01101000 + !byte $45,%10101000 + !byte $45,%11001000 + !byte $43,%00101001 + !byte $41,%10001001 + !byte $3F,%11001001 + !byte $3F,%00001010 + !byte $3D,%01001010 + !byte $3B,%10001010 + !byte $39,%11001010 + !byte $37,%00101011 + !byte $35,%01101011 + !byte $33,%10001011 + !byte $31,%11001011 + !byte $2F,%00001100 + !byte $2F,%00101100 + !byte $2D,%01001100 + !byte $2B,%01101100 + !byte $29,%10001100 + !byte $29,%10101100 + !byte $27,%11001100 + !byte $25,%00001101 + !byte $23,%00101101 + !byte $21,%01001101 + !byte $1F,%01101101 + !byte $1D,%10001101 + !byte $1B,%10001101 + !byte $19,%10101101 + !byte $17,%11001101 + !byte $15,%11001101 + !byte $13,%00001110 + !byte $11,%00001110 + !byte $11,%00101110 + !byte $0F,%00101110 + !byte $0D,%00101110 + !byte $0B,%01001110 + !byte $09,%01001110 + !byte $07,%01001110 + !byte $05,%01001110 + !byte $03,%01001110 + !byte $01,%01001110 + !byte $57,%00000000 + !byte $57,%00100000 + !byte $57,%01000000 + !byte $57,%01100000 + !byte $57,%10000000 + !byte $57,%10100000 + !byte $55,%01100010 + !byte $55,%10000010 + !byte $55,%10100010 + !byte $55,%11000010 + !byte $55,%00000011 + !byte $53,%11000011 + !byte $53,%00000100 + !byte $53,%00100100 + !byte $51,%11000100 + !byte $51,%00000101 + !byte $51,%00100101 + !byte $4F,%10100101 + !byte $4F,%11000101 + !byte $4D,%01100110 + !byte $4D,%10000110 + !byte $4B,%00000111 + !byte $4B,%00100111 + !byte $49,%10000111 + !byte $49,%10100111 + !byte $47,%00001000 + !byte $47,%00101000 + !byte $45,%01101000 + !byte $45,%10001000 + !byte $43,%11001000 + !byte $43,%00001001 + !byte $41,%01001001 + !byte $41,%01101001 + !byte $3F,%10101001 + !byte $3D,%00001010 + !byte $3D,%00101010 + !byte $3B,%01001010 + !byte $3B,%01101010 + !byte $39,%10001010 + !byte $39,%10101010 + !byte $37,%11001010 + !byte $37,%00001011 + !byte $35,%00101011 + !byte $35,%01001011 + !byte $33,%01101011 + !byte $31,%10101011 + !byte $2F,%11001011 + !byte $2D,%00101100 + !byte $2B,%01001100 + !byte $29,%01101100 + !byte $27,%10101100 + !byte $25,%11001100 + !byte $23,%00001101 + !byte $21,%00101101 + !byte $1F,%01001101 + !byte $1D,%01101101 + !byte $1B,%01101101 + !byte $19,%10001101 + !byte $17,%10101101 + !byte $15,%10101101 + !byte $13,%11001101 + !byte $11,%11001101 + !byte $0F,%00001110 + !byte $0D,%00001110 + !byte $0B,%00101110 + !byte $09,%00101110 + !byte $07,%00101110 + !byte $05,%00101110 + !byte $03,%00101110 + !byte $01,%00101110 + !byte $55,%01000001 + !byte $55,%01100001 + !byte $55,%10000001 + !byte $55,%10100001 + !byte $55,%11000001 + !byte $55,%00000010 + !byte $55,%00100010 + !byte $55,%01000010 + !byte $53,%01000011 + !byte $53,%01100011 + !byte $53,%10000011 + !byte $53,%10100011 + !byte $51,%01100100 + !byte $51,%10000100 + !byte $51,%10100100 + !byte $4F,%01000101 + !byte $4F,%01100101 + !byte $4F,%10000101 + !byte $4D,%00000110 + !byte $4D,%00100110 + !byte $4D,%01000110 + !byte $4B,%10100110 + !byte $4B,%11000110 + !byte $49,%01000111 + !byte $49,%01100111 + !byte $47,%10100111 + !byte $47,%11000111 + !byte $45,%01001000 + !byte $43,%10101000 + !byte $41,%00101001 + !byte $3F,%01101001 + !byte $3F,%10001001 + !byte $3D,%11001001 + !byte $3B,%00101010 + !byte $39,%01101010 + !byte $37,%10101010 + !byte $35,%00001011 + !byte $33,%01001011 + !byte $31,%01101011 + !byte $31,%10001011 + !byte $2F,%10101011 + !byte $2D,%00001100 + !byte $2B,%00101100 + !byte $29,%01001100 + !byte $27,%01101100 + !byte $27,%10001100 + !byte $25,%10101100 + !byte $23,%11001100 + !byte $21,%00001101 + !byte $1F,%00101101 + !byte $1D,%01001101 + !byte $1B,%01001101 + !byte $19,%01101101 + !byte $17,%10001101 + !byte $15,%10001101 + !byte $13,%10101101 + !byte $11,%10101101 + !byte $0F,%11001101 + !byte $0D,%11001101 + !byte $0B,%00001110 + !byte $09,%00001110 + !byte $07,%00001110 + !byte $05,%00001110 + !byte $03,%00001110 + !byte $01,%00001110 + !byte $55,%00000000 + !byte $55,%00100000 + !byte $55,%01000000 + !byte $55,%01100000 + !byte $55,%10000000 + !byte $55,%10100000 + !byte $55,%11000000 + !byte $55,%00000001 + !byte $55,%00100001 + !byte $53,%10000010 + !byte $53,%10100010 + !byte $53,%11000010 + !byte $53,%00000011 + !byte $53,%00100011 + !byte $51,%11000011 + !byte $51,%00000100 + !byte $51,%00100100 + !byte $51,%01000100 + !byte $4F,%11000100 + !byte $4F,%00000101 + !byte $4F,%00100101 + !byte $4D,%10100101 + !byte $4D,%11000101 + !byte $4B,%01100110 + !byte $4B,%10000110 + !byte $49,%00000111 + !byte $49,%00100111 + !byte $47,%10000111 + !byte $45,%00001000 + !byte $45,%00101000 + !byte $43,%01101000 + !byte $43,%10001000 + !byte $41,%11001000 + !byte $41,%00001001 + !byte $3F,%01001001 + !byte $3D,%10001001 + !byte $3D,%10101001 + !byte $3B,%00001010 + !byte $39,%01001010 + !byte $37,%10001010 + !byte $35,%11001010 + !byte $33,%00101011 + !byte $31,%01001011 + !byte $2F,%10001011 + !byte $2D,%10101011 + !byte $2D,%11001011 + !byte $2B,%00001100 + !byte $29,%00101100 + !byte $27,%01001100 + !byte $25,%01101100 + !byte $25,%10001100 + !byte $23,%10101100 + !byte $21,%11001100 + !byte $1F,%00001101 + !byte $1D,%00001101 + !byte $1D,%00101101 + !byte $1B,%00101101 + !byte $19,%01001101 + !byte $17,%01101101 + !byte $15,%01101101 + !byte $13,%10001101 + !byte $11,%10001101 + !byte $0F,%10101101 + !byte $0D,%10101101 + !byte $0B,%11001101 + !byte $09,%11001101 + !byte $07,%11001101 + !byte $05,%11001101 + !byte $03,%11001101 + !byte $01,%11001101 + !byte $53,%10100001 + !byte $53,%11000001 + !byte $53,%00000010 + !byte $53,%00100010 + !byte $53,%01000010 + !byte $53,%01100010 + !byte $51,%01100011 + !byte $51,%10000011 + !byte $51,%10100011 + !byte $4F,%01100100 + !byte $4F,%10000100 + !byte $4F,%10100100 + !byte $4D,%01100101 + !byte $4D,%10000101 + !byte $4B,%00000110 + !byte $4B,%00100110 + !byte $4B,%01000110 + !byte $49,%10100110 + !byte $49,%11000110 + !byte $47,%01000111 + !byte $47,%01100111 + !byte $45,%10100111 + !byte $45,%11000111 + !byte $43,%01001000 + !byte $41,%10001000 + !byte $41,%10101000 + !byte $3F,%00001001 + !byte $3F,%00101001 + !byte $3D,%01101001 + !byte $3B,%10101001 + !byte $3B,%11001001 + !byte $39,%00001010 + !byte $39,%00101010 + !byte $37,%01001010 + !byte $37,%01101010 + !byte $35,%10001010 + !byte $35,%10101010 + !byte $33,%11001010 + !byte $33,%00001011 + !byte $31,%00101011 + !byte $2F,%01101011 + !byte $2D,%10001011 + !byte $2B,%11001011 + !byte $29,%00001100 + !byte $27,%00101100 + !byte $25,%01001100 + !byte $23,%01101100 + !byte $23,%10001100 + !byte $21,%10001100 + !byte $21,%10101100 + !byte $1F,%10101100 + !byte $1F,%11001100 + !byte $1D,%11001100 + !byte $1B,%00001101 + !byte $19,%00101101 + !byte $17,%01001101 + !byte $15,%01001101 + !byte $13,%01101101 + !byte $11,%01101101 + !byte $0F,%10001101 + !byte $0D,%10001101 + !byte $0B,%10101101 + !byte $09,%10101101 + !byte $07,%10101101 + !byte $05,%10101101 + !byte $03,%10101101 + !byte $01,%10101101 + !byte $53,%00000000 + !byte $53,%00100000 + !byte $53,%01000000 + !byte $53,%01100000 + !byte $53,%10000000 + !byte $53,%10100000 + !byte $53,%11000000 + !byte $53,%00000001 + !byte $53,%00100001 + !byte $53,%01000001 + !byte $53,%01100001 + !byte $53,%10000001 + !byte $51,%11000010 + !byte $51,%00000011 + !byte $51,%00100011 + !byte $51,%01000011 + !byte $4F,%00000100 + !byte $4F,%00100100 + !byte $4F,%01000100 + !byte $4D,%00000101 + !byte $4D,%00100101 + !byte $4D,%01000101 + !byte $4B,%10100101 + !byte $4B,%11000101 + !byte $49,%01100110 + !byte $49,%10000110 + !byte $47,%00000111 + !byte $47,%00100111 + !byte $45,%01100111 + !byte $45,%10000111 + !byte $43,%00001000 + !byte $43,%00101000 + !byte $41,%01101000 + !byte $3F,%11001000 + !byte $3D,%00101001 + !byte $3D,%01001001 + !byte $3B,%10001001 + !byte $39,%11001001 + !byte $37,%00101010 + !byte $35,%01101010 + !byte $33,%10101010 + !byte $31,%00001011 + !byte $2F,%00101011 + !byte $2F,%01001011 + !byte $2D,%01101011 + !byte $2B,%10001011 + !byte $2B,%10101011 + !byte $29,%11001011 + !byte $27,%00001100 + !byte $25,%00101100 + !byte $23,%01001100 + !byte $21,%01101100 + !byte $1F,%10001100 + !byte $1D,%10101100 + !byte $1B,%11001100 + !byte $19,%00001101 + !byte $17,%00101101 + !byte $15,%00101101 + !byte $13,%01001101 + !byte $11,%01001101 + !byte $0F,%01101101 + !byte $0D,%01101101 + !byte $0B,%10001101 + !byte $09,%10001101 + !byte $07,%10001101 + !byte $05,%10001101 + !byte $03,%10001101 + !byte $01,%10001101 + !byte $51,%00000010 + !byte $51,%00100010 + !byte $51,%01000010 + !byte $51,%01100010 + !byte $51,%10000010 + !byte $51,%10100010 + !byte $4F,%10000011 + !byte $4F,%10100011 + !byte $4F,%11000011 + !byte $4D,%10000100 + !byte $4D,%10100100 + !byte $4D,%11000100 + !byte $4B,%01100101 + !byte $4B,%10000101 + !byte $49,%00100110 + !byte $49,%01000110 + !byte $47,%10100110 + !byte $47,%11000110 + !byte $45,%01000111 + !byte $43,%10100111 + !byte $43,%11000111 + !byte $41,%00101000 + !byte $41,%01001000 + !byte $3F,%10001000 + !byte $3F,%10101000 + !byte $3D,%00001001 + !byte $3B,%01001001 + !byte $3B,%01101001 + !byte $39,%10101001 + !byte $37,%00001010 + !byte $35,%01001010 + !byte $33,%10001010 + !byte $31,%11001010 + !byte $2F,%00001011 + !byte $2D,%01001011 + !byte $2B,%01101011 + !byte $29,%10101011 + !byte $27,%11001011 + !byte $25,%00001100 + !byte $23,%00101100 + !byte $21,%01001100 + !byte $1F,%01101100 + !byte $1D,%10001100 + !byte $1B,%10101100 + !byte $19,%11001100 + !byte $17,%00001101 + !byte $15,%00001101 + !byte $13,%00101101 + !byte $11,%00101101 + !byte $0F,%01001101 + !byte $0D,%01001101 + !byte $0B,%01101101 + !byte $09,%01101101 + !byte $07,%01101101 + !byte $05,%01101101 + !byte $03,%01101101 + !byte $01,%01101101 + !byte $51,%01100000 + !byte $51,%10000000 + !byte $51,%10100000 + !byte $51,%11000000 + !byte $51,%00000001 + !byte $51,%00100001 + !byte $51,%01000001 + !byte $51,%01100001 + !byte $51,%10000001 + !byte $51,%10100001 + !byte $51,%11000001 + !byte $4F,%00000011 + !byte $4F,%00100011 + !byte $4F,%01000011 + !byte $4F,%01100011 + !byte $4D,%00100100 + !byte $4D,%01000100 + !byte $4D,%01100100 + !byte $4B,%00000101 + !byte $4B,%00100101 + !byte $4B,%01000101 + !byte $49,%10100101 + !byte $49,%11000101 + !byte $49,%00000110 + !byte $47,%01100110 + !byte $47,%10000110 + !byte $45,%00000111 + !byte $45,%00100111 + !byte $43,%01100111 + !byte $43,%10000111 + !byte $41,%00001000 + !byte $3F,%01101000 + !byte $3D,%10101000 + !byte $3D,%11001000 + !byte $3B,%00101001 + !byte $39,%01101001 + !byte $39,%10001001 + !byte $37,%10101001 + !byte $37,%11001001 + !byte $35,%00101010 + !byte $33,%01001010 + !byte $33,%01101010 + !byte $31,%10001010 + !byte $31,%10101010 + !byte $2F,%11001010 + !byte $2D,%00001011 + !byte $2D,%00101011 + !byte $2B,%01001011 + !byte $29,%01101011 + !byte $29,%10001011 + !byte $27,%10101011 + !byte $25,%11001011 + !byte $23,%00001100 + !byte $21,%00101100 + !byte $1F,%01001100 + !byte $1D,%01101100 + !byte $1B,%10001100 + !byte $19,%10101100 + !byte $17,%11001100 + !byte $15,%11001100 + !byte $13,%00001101 + !byte $11,%00001101 + !byte $0F,%00101101 + !byte $0D,%00101101 + !byte $0B,%01001101 + !byte $09,%01001101 + !byte $07,%01001101 + !byte $05,%01001101 + !byte $03,%01001101 + !byte $01,%01001101 + !byte $51,%00000000 + !byte $51,%00100000 + !byte $51,%01000000 + !byte $4F,%01000010 + !byte $4F,%01100010 + !byte $4F,%10000010 + !byte $4F,%10100010 + !byte $4F,%11000010 + !byte $4D,%10100011 + !byte $4D,%11000011 + !byte $4D,%00000100 + !byte $4B,%10000100 + !byte $4B,%10100100 + !byte $4B,%11000100 + !byte $49,%01100101 + !byte $49,%10000101 + !byte $47,%00100110 + !byte $47,%01000110 + !byte $45,%10100110 + !byte $45,%11000110 + !byte $43,%01000111 + !byte $41,%10100111 + !byte $41,%11000111 + !byte $3F,%00101000 + !byte $3F,%01001000 + !byte $3D,%10001000 + !byte $3B,%11001000 + !byte $3B,%00001001 + !byte $39,%01001001 + !byte $37,%10001001 + !byte $35,%11001001 + !byte $35,%00001010 + !byte $33,%00101010 + !byte $31,%01101010 + !byte $2F,%10101010 + !byte $2D,%11001010 + !byte $2B,%00101011 + !byte $29,%01001011 + !byte $27,%10001011 + !byte $25,%10101011 + !byte $23,%11001011 + !byte $21,%00001100 + !byte $1F,%00101100 + !byte $1D,%01001100 + !byte $1B,%01101100 + !byte $19,%10001100 + !byte $17,%10001100 + !byte $17,%10101100 + !byte $15,%10101100 + !byte $13,%11001100 + !byte $11,%11001100 + !byte $0F,%00001101 + !byte $0D,%00001101 + !byte $0B,%00101101 + !byte $09,%00101101 + !byte $07,%00101101 + !byte $05,%00101101 + !byte $03,%00101101 + !byte $01,%00101101 + !byte $4F,%00100001 + !byte $4F,%01000001 + !byte $4F,%01100001 + !byte $4F,%10000001 + !byte $4F,%10100001 + !byte $4F,%11000001 + !byte $4F,%00000010 + !byte $4F,%00100010 + !byte $4D,%00100011 + !byte $4D,%01000011 + !byte $4D,%01100011 + !byte $4D,%10000011 + !byte $4B,%00100100 + !byte $4B,%01000100 + !byte $4B,%01100100 + !byte $49,%00000101 + !byte $49,%00100101 + !byte $49,%01000101 + !byte $47,%11000101 + !byte $47,%00000110 + !byte $45,%01100110 + !byte $45,%10000110 + !byte $43,%00000111 + !byte $43,%00100111 + !byte $41,%01100111 + !byte $41,%10000111 + !byte $3F,%11000111 + !byte $3F,%00001000 + !byte $3D,%01001000 + !byte $3D,%01101000 + !byte $3B,%10101000 + !byte $39,%00001001 + !byte $39,%00101001 + !byte $37,%01101001 + !byte $35,%10101001 + !byte $33,%00001010 + !byte $31,%01001010 + !byte $2F,%01101010 + !byte $2F,%10001010 + !byte $2D,%10101010 + !byte $2B,%00001011 + !byte $29,%00101011 + !byte $27,%01001011 + !byte $27,%01101011 + !byte $25,%10001011 + !byte $23,%10101011 + !byte $21,%11001011 + !byte $1F,%00001100 + !byte $1D,%00101100 + !byte $1B,%01001100 + !byte $19,%01101100 + !byte $17,%01101100 + !byte $15,%10001100 + !byte $13,%10101100 + !byte $11,%10101100 + !byte $0F,%11001100 + !byte $0D,%11001100 + !byte $0B,%00001101 + !byte $09,%00001101 + !byte $07,%00001101 + !byte $05,%00001101 + !byte $03,%00001101 + !byte $01,%00001101 + !byte $4F,%00000000 + !byte $4F,%00100000 + !byte $4F,%01000000 + !byte $4F,%01100000 + !byte $4F,%10000000 + !byte $4F,%10100000 + !byte $4F,%11000000 + !byte $4F,%00000001 + !byte $4D,%01100010 + !byte $4D,%10000010 + !byte $4D,%10100010 + !byte $4D,%11000010 + !byte $4D,%00000011 + !byte $4B,%10100011 + !byte $4B,%11000011 + !byte $4B,%00000100 + !byte $49,%10100100 + !byte $49,%11000100 + !byte $47,%01100101 + !byte $47,%10000101 + !byte $47,%10100101 + !byte $45,%00100110 + !byte $45,%01000110 + !byte $43,%10100110 + !byte $43,%11000110 + !byte $41,%00100111 + !byte $41,%01000111 + !byte $3F,%10100111 + !byte $3D,%00101000 + !byte $3B,%01101000 + !byte $3B,%10001000 + !byte $39,%11001000 + !byte $37,%00101001 + !byte $37,%01001001 + !byte $35,%01101001 + !byte $35,%10001001 + !byte $33,%11001001 + !byte $31,%00001010 + !byte $31,%00101010 + !byte $2F,%01001010 + !byte $2D,%10001010 + !byte $2B,%10101010 + !byte $2B,%11001010 + !byte $29,%00001011 + !byte $27,%00101011 + !byte $25,%01101011 + !byte $23,%10001011 + !byte $21,%10101011 + !byte $1F,%11001011 + !byte $1D,%00001100 + !byte $1B,%00101100 + !byte $19,%01001100 + !byte $17,%01001100 + !byte $15,%01101100 + !byte $13,%10001100 + !byte $11,%10001100 + !byte $0F,%10101100 + !byte $0D,%10101100 + !byte $0B,%11001100 + !byte $09,%11001100 + !byte $07,%11001100 + !byte $05,%11001100 + !byte $03,%11001100 + !byte $01,%11001100 + !byte $4D,%10000001 + !byte $4D,%10100001 + !byte $4D,%11000001 + !byte $4D,%00000010 + !byte $4D,%00100010 + !byte $4D,%01000010 + !byte $4B,%01000011 + !byte $4B,%01100011 + !byte $4B,%10000011 + !byte $49,%01000100 + !byte $49,%01100100 + !byte $49,%10000100 + !byte $47,%00100101 + !byte $47,%01000101 + !byte $45,%11000101 + !byte $45,%00000110 + !byte $43,%01100110 + !byte $43,%10000110 + !byte $41,%00000111 + !byte $3F,%01100111 + !byte $3F,%10000111 + !byte $3D,%11000111 + !byte $3D,%00001000 + !byte $3B,%01001000 + !byte $39,%10101000 + !byte $37,%00001001 + !byte $35,%01001001 + !byte $33,%10001001 + !byte $33,%10101001 + !byte $31,%11001001 + !byte $2F,%00101010 + !byte $2D,%01101010 + !byte $2B,%10001010 + !byte $29,%11001010 + !byte $27,%00001011 + !byte $25,%00101011 + !byte $25,%01001011 + !byte $23,%01101011 + !byte $21,%10001011 + !byte $1F,%10101011 + !byte $1D,%11001011 + !byte $1B,%00001100 + !byte $19,%00101100 + !byte $17,%00101100 + !byte $15,%01001100 + !byte $13,%01101100 + !byte $11,%01101100 + !byte $0F,%10001100 + !byte $0D,%10001100 + !byte $0B,%10101100 + !byte $09,%10101100 + !byte $07,%10101100 + !byte $05,%10101100 + !byte $03,%10101100 + !byte $01,%10101100 + !byte $4D,%00000000 + !byte $4D,%00100000 + !byte $4D,%01000000 + !byte $4D,%01100000 + !byte $4D,%10000000 + !byte $4D,%10100000 + !byte $4D,%11000000 + !byte $4D,%00000001 + !byte $4D,%00100001 + !byte $4D,%01000001 + !byte $4D,%01100001 + !byte $4B,%10000010 + !byte $4B,%10100010 + !byte $4B,%11000010 + !byte $4B,%00000011 + !byte $4B,%00100011 + !byte $49,%11000011 + !byte $49,%00000100 + !byte $49,%00100100 + !byte $47,%10100100 + !byte $47,%11000100 + !byte $47,%00000101 + !byte $45,%01100101 + !byte $45,%10000101 + !byte $45,%10100101 + !byte $43,%00100110 + !byte $43,%01000110 + !byte $41,%10100110 + !byte $41,%11000110 + !byte $3F,%00100111 + !byte $3F,%01000111 + !byte $3D,%10000111 + !byte $3D,%10100111 + !byte $3B,%00001000 + !byte $3B,%00101000 + !byte $39,%01101000 + !byte $39,%10001000 + !byte $37,%10101000 + !byte $37,%11001000 + !byte $35,%00101001 + !byte $33,%01101001 + !byte $31,%10101001 + !byte $2F,%00001010 + !byte $2D,%00101010 + !byte $2D,%01001010 + !byte $2B,%01101010 + !byte $29,%10101010 + !byte $27,%11001010 + !byte $25,%00001011 + !byte $23,%01001011 + !byte $21,%01101011 + !byte $1F,%10001011 + !byte $1D,%10101011 + !byte $1B,%11001011 + !byte $19,%00001100 + !byte $17,%00001100 + !byte $15,%00101100 + !byte $13,%01001100 + !byte $11,%01001100 + !byte $0F,%01101100 + !byte $0D,%01101100 + !byte $0B,%10001100 + !byte $09,%10001100 + !byte $07,%10001100 + !byte $05,%10001100 + !byte $03,%10001100 + !byte $01,%10001100 + !byte $4B,%11000001 + !byte $4B,%00000010 + !byte $4B,%00100010 + !byte $4B,%01000010 + !byte $4B,%01100010 + !byte $49,%01000011 + !byte $49,%01100011 + !byte $49,%10000011 + !byte $49,%10100011 + !byte $47,%01000100 + !byte $47,%01100100 + !byte $47,%10000100 + !byte $45,%00100101 + !byte $45,%01000101 + !byte $43,%11000101 + !byte $43,%00000110 + !byte $41,%01100110 + !byte $41,%10000110 + !byte $3F,%11000110 + !byte $3F,%00000111 + !byte $3D,%01100111 + !byte $3B,%11000111 + !byte $39,%00101000 + !byte $39,%01001000 + !byte $37,%10001000 + !byte $35,%11001000 + !byte $35,%00001001 + !byte $33,%00101001 + !byte $33,%01001001 + !byte $31,%10001001 + !byte $2F,%10101001 + !byte $2F,%11001001 + !byte $2D,%00001010 + !byte $2B,%01001010 + !byte $29,%01101010 + !byte $29,%10001010 + !byte $27,%10101010 + !byte $25,%11001010 + !byte $23,%00001011 + !byte $23,%00101011 + !byte $21,%01001011 + !byte $1F,%01101011 + !byte $1D,%10001011 + !byte $1B,%10101011 + !byte $19,%10101011 + !byte $19,%11001011 + !byte $17,%11001011 + !byte $15,%00001100 + !byte $13,%00101100 + !byte $11,%00101100 + !byte $0F,%01001100 + !byte $0D,%01001100 + !byte $0B,%01101100 + !byte $09,%01101100 + !byte $07,%01101100 + !byte $05,%01101100 + !byte $03,%01101100 + !byte $01,%01101100 + !byte $4B,%00000000 + !byte $4B,%00100000 + !byte $4B,%01000000 + !byte $4B,%01100000 + !byte $4B,%10000000 + !byte $4B,%10100000 + !byte $4B,%11000000 + !byte $4B,%00000001 + !byte $4B,%00100001 + !byte $4B,%01000001 + !byte $4B,%01100001 + !byte $4B,%10000001 + !byte $4B,%10100001 + !byte $49,%11000010 + !byte $49,%00000011 + !byte $49,%00100011 + !byte $47,%11000011 + !byte $47,%00000100 + !byte $47,%00100100 + !byte $45,%11000100 + !byte $45,%00000101 + !byte $43,%01100101 + !byte $43,%10000101 + !byte $43,%10100101 + !byte $41,%00100110 + !byte $41,%01000110 + !byte $3F,%10100110 + !byte $3D,%00100111 + !byte $3D,%01000111 + !byte $3B,%10000111 + !byte $3B,%10100111 + !byte $39,%00001000 + !byte $37,%01101000 + !byte $35,%10101000 + !byte $33,%00001001 + !byte $31,%01001001 + !byte $31,%01101001 + !byte $2F,%10001001 + !byte $2D,%11001001 + !byte $2B,%00101010 + !byte $29,%01001010 + !byte $27,%10001010 + !byte $25,%10101010 + !byte $23,%11001010 + !byte $21,%00001011 + !byte $21,%00101011 + !byte $1F,%01001011 + !byte $1D,%01101011 + !byte $1B,%10001011 + !byte $19,%10001011 + !byte $17,%10101011 + !byte $15,%11001011 + !byte $13,%00001100 + !byte $11,%00001100 + !byte $0F,%00101100 + !byte $0D,%00101100 + !byte $0B,%00101100 + !byte $0B,%01001100 + !byte $09,%01001100 + !byte $07,%01001100 + !byte $05,%01001100 + !byte $03,%01001100 + !byte $01,%01001100 + !byte $49,%00000010 + !byte $49,%00100010 + !byte $49,%01000010 + !byte $49,%01100010 + !byte $49,%10000010 + !byte $49,%10100010 + !byte $47,%01100011 + !byte $47,%10000011 + !byte $47,%10100011 + !byte $45,%01100100 + !byte $45,%10000100 + !byte $45,%10100100 + !byte $43,%00100101 + !byte $43,%01000101 + !byte $41,%11000101 + !byte $41,%00000110 + !byte $3F,%01100110 + !byte $3F,%10000110 + !byte $3D,%11000110 + !byte $3D,%00000111 + !byte $3B,%01000111 + !byte $3B,%01100111 + !byte $39,%10100111 + !byte $39,%11000111 + !byte $37,%00101000 + !byte $37,%01001000 + !byte $35,%10001000 + !byte $33,%11001000 + !byte $31,%00101001 + !byte $2F,%01101001 + !byte $2D,%10101001 + !byte $2B,%11001001 + !byte $2B,%00001010 + !byte $29,%00101010 + !byte $27,%01101010 + !byte $25,%10001010 + !byte $23,%10101010 + !byte $21,%11001010 + !byte $1F,%00001011 + !byte $1F,%00101011 + !byte $1D,%00101011 + !byte $1D,%01001011 + !byte $1B,%01001011 + !byte $1B,%01101011 + !byte $19,%01101011 + !byte $17,%10001011 + !byte $15,%10101011 + !byte $13,%11001011 + !byte $11,%11001011 + !byte $0F,%00001100 + !byte $0D,%00001100 + !byte $0B,%00001100 + !byte $09,%00101100 + !byte $07,%00101100 + !byte $05,%00101100 + !byte $03,%00101100 + !byte $01,%00101100 + !byte $49,%11000000 + !byte $49,%00000001 + !byte $49,%00100001 + !byte $49,%01000001 + !byte $49,%01100001 + !byte $49,%10000001 + !byte $49,%10100001 + !byte $49,%11000001 + !byte $47,%11000010 + !byte $47,%00000011 + !byte $47,%00100011 + !byte $47,%01000011 + !byte $45,%00000100 + !byte $45,%00100100 + !byte $45,%01000100 + !byte $43,%11000100 + !byte $43,%00000101 + !byte $41,%10000101 + !byte $41,%10100101 + !byte $3F,%00100110 + !byte $3F,%01000110 + !byte $3D,%10000110 + !byte $3D,%10100110 + !byte $3B,%00100111 + !byte $39,%10000111 + !byte $37,%11000111 + !byte $37,%00001000 + !byte $35,%01001000 + !byte $35,%01101000 + !byte $33,%10001000 + !byte $33,%10101000 + !byte $31,%00001001 + !byte $2F,%00101001 + !byte $2F,%01001001 + !byte $2D,%01101001 + !byte $2D,%10001001 + !byte $2B,%10101001 + !byte $29,%00001010 + !byte $27,%00101010 + !byte $27,%01001010 + !byte $25,%01101010 + !byte $23,%10001010 + !byte $21,%10101010 + !byte $1F,%11001010 + !byte $1D,%00001011 + !byte $1B,%00101011 + !byte $19,%01001011 + !byte $17,%01101011 + !byte $15,%10001011 + !byte $13,%10001011 + !byte $13,%10101011 + !byte $11,%10101011 + !byte $0F,%11001011 + !byte $0D,%11001011 + !byte $0B,%11001011 + !byte $09,%00001100 + !byte $07,%00001100 + !byte $05,%00001100 + !byte $03,%00001100 + !byte $01,%00001100 + !byte $49,%00000000 + !byte $49,%00100000 + !byte $49,%01000000 + !byte $49,%01100000 + !byte $49,%10000000 + !byte $49,%10100000 + !byte $47,%01000010 + !byte $47,%01100010 + !byte $47,%10000010 + !byte $47,%10100010 + !byte $45,%10000011 + !byte $45,%10100011 + !byte $45,%11000011 + !byte $43,%01100100 + !byte $43,%10000100 + !byte $43,%10100100 + !byte $41,%00100101 + !byte $41,%01000101 + !byte $41,%01100101 + !byte $3F,%11000101 + !byte $3F,%00000110 + !byte $3D,%01100110 + !byte $3B,%11000110 + !byte $3B,%00000111 + !byte $39,%01000111 + !byte $39,%01100111 + !byte $37,%10100111 + !byte $35,%00101000 + !byte $33,%01101000 + !byte $31,%10101000 + !byte $31,%11001000 + !byte $2F,%00001001 + !byte $2D,%01001001 + !byte $2B,%10001001 + !byte $29,%11001001 + !byte $27,%00001010 + !byte $25,%01001010 + !byte $23,%01101010 + !byte $21,%10001010 + !byte $1F,%10101010 + !byte $1D,%11001010 + !byte $1B,%00001011 + !byte $19,%00101011 + !byte $17,%01001011 + !byte $15,%01101011 + !byte $13,%01101011 + !byte $11,%10001011 + !byte $0F,%10101011 + !byte $0D,%10101011 + !byte $0B,%10101011 + !byte $09,%11001011 + !byte $07,%11001011 + !byte $05,%11001011 + !byte $03,%11001011 + !byte $01,%11001011 + !byte $47,%01000001 + !byte $47,%01100001 + !byte $47,%10000001 + !byte $47,%10100001 + !byte $47,%11000001 + !byte $47,%00000010 + !byte $47,%00100010 + !byte $45,%00000011 + !byte $45,%00100011 + !byte $45,%01000011 + !byte $45,%01100011 + !byte $43,%00000100 + !byte $43,%00100100 + !byte $43,%01000100 + !byte $41,%11000100 + !byte $41,%00000101 + !byte $3F,%10000101 + !byte $3F,%10100101 + !byte $3D,%00100110 + !byte $3D,%01000110 + !byte $3B,%10000110 + !byte $3B,%10100110 + !byte $39,%00000111 + !byte $39,%00100111 + !byte $37,%01100111 + !byte $37,%10000111 + !byte $35,%11000111 + !byte $35,%00001000 + !byte $33,%01001000 + !byte $31,%10001000 + !byte $2F,%11001000 + !byte $2D,%00101001 + !byte $2B,%01101001 + !byte $29,%10001001 + !byte $29,%10101001 + !byte $27,%11001001 + !byte $25,%00001010 + !byte $25,%00101010 + !byte $23,%01001010 + !byte $21,%01101010 + !byte $1F,%10001010 + !byte $1D,%10101010 + !byte $1B,%11001010 + !byte $19,%00001011 + !byte $17,%00101011 + !byte $15,%01001011 + !byte $13,%01001011 + !byte $11,%01101011 + !byte $0F,%10001011 + !byte $0D,%10001011 + !byte $0B,%10001011 + !byte $09,%10101011 + !byte $07,%10101011 + !byte $05,%10101011 + !byte $03,%10101011 + !byte $01,%10101011 + !byte $47,%00000000 + !byte $47,%00100000 + !byte $47,%01000000 + !byte $47,%01100000 + !byte $47,%10000000 + !byte $47,%10100000 + !byte $47,%11000000 + !byte $47,%00000001 + !byte $47,%00100001 + !byte $45,%01100010 + !byte $45,%10000010 + !byte $45,%10100010 + !byte $45,%11000010 + !byte $43,%10100011 + !byte $43,%11000011 + !byte $41,%10000100 + !byte $41,%10100100 + !byte $3F,%01000101 + !byte $3F,%01100101 + !byte $3D,%11000101 + !byte $3D,%00000110 + !byte $3B,%01000110 + !byte $3B,%01100110 + !byte $39,%11000110 + !byte $37,%01000111 + !byte $35,%10100111 + !byte $33,%00001000 + !byte $33,%00101000 + !byte $31,%01001000 + !byte $31,%01101000 + !byte $2F,%10101000 + !byte $2D,%11001000 + !byte $2D,%00001001 + !byte $2B,%00101001 + !byte $2B,%01001001 + !byte $29,%01101001 + !byte $27,%10101001 + !byte $25,%11001001 + !byte $23,%00101010 + !byte $21,%01001010 + !byte $1F,%01101010 + !byte $1D,%10001010 + !byte $1B,%10101010 + !byte $19,%11001010 + !byte $17,%00001011 + !byte $15,%00101011 + !byte $13,%00101011 + !byte $11,%01001011 + !byte $0F,%01101011 + !byte $0D,%01101011 + !byte $0B,%01101011 + !byte $09,%10001011 + !byte $07,%10001011 + !byte $05,%10001011 + !byte $03,%10001011 + !byte $01,%10001011 + !byte $45,%10000001 + !byte $45,%10100001 + !byte $45,%11000001 + !byte $45,%00000010 + !byte $45,%00100010 + !byte $45,%01000010 + !byte $43,%00100011 + !byte $43,%01000011 + !byte $43,%01100011 + !byte $43,%10000011 + !byte $41,%00100100 + !byte $41,%01000100 + !byte $41,%01100100 + !byte $3F,%11000100 + !byte $3F,%00000101 + !byte $3F,%00100101 + !byte $3D,%10000101 + !byte $3D,%10100101 + !byte $3B,%00100110 + !byte $39,%10000110 + !byte $39,%10100110 + !byte $37,%00000111 + !byte $37,%00100111 + !byte $35,%01100111 + !byte $35,%10000111 + !byte $33,%11000111 + !byte $31,%00101000 + !byte $2F,%01101000 + !byte $2F,%10001000 + !byte $2D,%10101000 + !byte $2B,%00001001 + !byte $29,%01001001 + !byte $27,%10001001 + !byte $25,%10101001 + !byte $23,%11001001 + !byte $23,%00001010 + !byte $21,%00101010 + !byte $1F,%01001010 + !byte $1D,%01101010 + !byte $1B,%10001010 + !byte $19,%10101010 + !byte $17,%11001010 + !byte $15,%00001011 + !byte $13,%00001011 + !byte $11,%00101011 + !byte $0F,%01001011 + !byte $0D,%01001011 + !byte $0B,%01001011 + !byte $09,%01101011 + !byte $07,%01101011 + !byte $05,%01101011 + !byte $03,%01101011 + !byte $01,%01101011 + !byte $45,%00000000 + !byte $45,%00100000 + !byte $45,%01000000 + !byte $45,%01100000 + !byte $45,%10000000 + !byte $45,%10100000 + !byte $45,%11000000 + !byte $45,%00000001 + !byte $45,%00100001 + !byte $45,%01000001 + !byte $45,%01100001 + !byte $43,%10000010 + !byte $43,%10100010 + !byte $43,%11000010 + !byte $43,%00000011 + !byte $41,%10100011 + !byte $41,%11000011 + !byte $41,%00000100 + !byte $3F,%10000100 + !byte $3F,%10100100 + !byte $3D,%01000101 + !byte $3D,%01100101 + !byte $3B,%11000101 + !byte $3B,%00000110 + !byte $39,%01000110 + !byte $39,%01100110 + !byte $37,%11000110 + !byte $35,%01000111 + !byte $33,%10000111 + !byte $33,%10100111 + !byte $31,%00001000 + !byte $2F,%01001000 + !byte $2D,%10001000 + !byte $2B,%11001000 + !byte $29,%00101001 + !byte $27,%01001001 + !byte $27,%01101001 + !byte $25,%10001001 + !byte $23,%10101001 + !byte $21,%00001010 + !byte $1F,%00101010 + !byte $1D,%01001010 + !byte $1B,%01101010 + !byte $19,%10001010 + !byte $17,%10101010 + !byte $15,%11001010 + !byte $13,%11001010 + !byte $11,%00001011 + !byte $0F,%00001011 + !byte $0F,%00101011 + !byte $0D,%00101011 + !byte $0B,%00101011 + !byte $09,%01001011 + !byte $07,%01001011 + !byte $05,%01001011 + !byte $03,%01001011 + !byte $01,%01001011 + !byte $43,%11000001 + !byte $43,%00000010 + !byte $43,%00100010 + !byte $43,%01000010 + !byte $43,%01100010 + !byte $41,%01000011 + !byte $41,%01100011 + !byte $41,%10000011 + !byte $3F,%00100100 + !byte $3F,%01000100 + !byte $3F,%01100100 + !byte $3D,%11000100 + !byte $3D,%00000101 + !byte $3D,%00100101 + !byte $3B,%10000101 + !byte $3B,%10100101 + !byte $39,%00000110 + !byte $39,%00100110 + !byte $37,%10000110 + !byte $37,%10100110 + !byte $35,%00000111 + !byte $35,%00100111 + !byte $33,%01100111 + !byte $31,%10100111 + !byte $31,%11000111 + !byte $2F,%00001000 + !byte $2F,%00101000 + !byte $2D,%01101000 + !byte $2B,%10101000 + !byte $29,%11001000 + !byte $29,%00001001 + !byte $27,%00101001 + !byte $25,%01101001 + !byte $23,%10001001 + !byte $21,%10101001 + !byte $21,%11001001 + !byte $1F,%00001010 + !byte $1D,%00101010 + !byte $1B,%01001010 + !byte $19,%01101010 + !byte $17,%10001010 + !byte $15,%10101010 + !byte $13,%10101010 + !byte $11,%11001010 + !byte $0F,%11001010 + !byte $0D,%00001011 + !byte $0B,%00001011 + !byte $09,%00101011 + !byte $07,%00101011 + !byte $05,%00101011 + !byte $03,%00101011 + !byte $01,%00101011 + !byte $43,%10100000 + !byte $43,%11000000 + !byte $43,%00000001 + !byte $43,%00100001 + !byte $43,%01000001 + !byte $43,%01100001 + !byte $43,%10000001 + !byte $43,%10100001 + !byte $41,%10100010 + !byte $41,%11000010 + !byte $41,%00000011 + !byte $41,%00100011 + !byte $3F,%10100011 + !byte $3F,%11000011 + !byte $3F,%00000100 + !byte $3D,%10000100 + !byte $3D,%10100100 + !byte $3B,%01000101 + !byte $3B,%01100101 + !byte $39,%11000101 + !byte $37,%01000110 + !byte $37,%01100110 + !byte $35,%10100110 + !byte $35,%11000110 + !byte $33,%00100111 + !byte $33,%01000111 + !byte $31,%10000111 + !byte $2F,%11000111 + !byte $2D,%00101000 + !byte $2D,%01001000 + !byte $2B,%01101000 + !byte $2B,%10001000 + !byte $29,%10101000 + !byte $27,%00001001 + !byte $25,%00101001 + !byte $25,%01001001 + !byte $23,%01101001 + !byte $21,%10001001 + !byte $1F,%11001001 + !byte $1D,%00001010 + !byte $1B,%00101010 + !byte $19,%01001010 + !byte $17,%01101010 + !byte $15,%01101010 + !byte $15,%10001010 + !byte $13,%10001010 + !byte $11,%10101010 + !byte $0F,%10101010 + !byte $0D,%11001010 + !byte $0B,%11001010 + !byte $09,%00001011 + !byte $07,%00001011 + !byte $05,%00001011 + !byte $03,%00001011 + !byte $01,%00001011 + !byte $43,%00000000 + !byte $43,%00100000 + !byte $43,%01000000 + !byte $43,%01100000 + !byte $43,%10000000 + !byte $41,%00100010 + !byte $41,%01000010 + !byte $41,%01100010 + !byte $41,%10000010 + !byte $3F,%01000011 + !byte $3F,%01100011 + !byte $3F,%10000011 + !byte $3D,%01000100 + !byte $3D,%01100100 + !byte $3B,%11000100 + !byte $3B,%00000101 + !byte $3B,%00100101 + !byte $39,%10000101 + !byte $39,%10100101 + !byte $37,%00000110 + !byte $37,%00100110 + !byte $35,%10000110 + !byte $33,%00000111 + !byte $31,%01000111 + !byte $31,%01100111 + !byte $2F,%10100111 + !byte $2D,%00001000 + !byte $2B,%01001000 + !byte $29,%10001000 + !byte $27,%11001000 + !byte $25,%00001001 + !byte $23,%01001001 + !byte $21,%01101001 + !byte $1F,%10001001 + !byte $1F,%10101001 + !byte $1D,%11001001 + !byte $1B,%00001010 + !byte $19,%00101010 + !byte $17,%01001010 + !byte $15,%01001010 + !byte $13,%01101010 + !byte $11,%10001010 + !byte $0F,%10001010 + !byte $0D,%10101010 + !byte $0B,%10101010 + !byte $09,%11001010 + !byte $07,%11001010 + !byte $05,%11001010 + !byte $03,%11001010 + !byte $01,%11001010 + !byte $41,%00100001 + !byte $41,%01000001 + !byte $41,%01100001 + !byte $41,%10000001 + !byte $41,%10100001 + !byte $41,%11000001 + !byte $41,%00000010 + !byte $3F,%11000010 + !byte $3F,%00000011 + !byte $3F,%00100011 + !byte $3D,%11000011 + !byte $3D,%00000100 + !byte $3D,%00100100 + !byte $3B,%10000100 + !byte $3B,%10100100 + !byte $39,%01000101 + !byte $39,%01100101 + !byte $37,%11000101 + !byte $35,%01000110 + !byte $35,%01100110 + !byte $33,%10100110 + !byte $33,%11000110 + !byte $31,%00100111 + !byte $2F,%01100111 + !byte $2F,%10000111 + !byte $2D,%10100111 + !byte $2D,%11000111 + !byte $2B,%00101000 + !byte $29,%01101000 + !byte $27,%10001000 + !byte $27,%10101000 + !byte $25,%11001000 + !byte $23,%00101001 + !byte $21,%01001001 + !byte $1F,%01101001 + !byte $1D,%10001001 + !byte $1D,%10101001 + !byte $1B,%11001001 + !byte $19,%00001010 + !byte $17,%00001010 + !byte $17,%00101010 + !byte $15,%00101010 + !byte $13,%01001010 + !byte $11,%01101010 + !byte $0F,%01101010 + !byte $0D,%10001010 + !byte $0B,%10001010 + !byte $09,%10101010 + !byte $07,%10101010 + !byte $05,%10101010 + !byte $03,%10101010 + !byte $01,%10101010 + !byte $41,%00000000 + !byte $41,%00100000 + !byte $41,%01000000 + !byte $41,%01100000 + !byte $41,%10000000 + !byte $41,%10100000 + !byte $41,%11000000 + !byte $41,%00000001 + !byte $3F,%01000010 + !byte $3F,%01100010 + !byte $3F,%10000010 + !byte $3F,%10100010 + !byte $3D,%01100011 + !byte $3D,%10000011 + !byte $3D,%10100011 + !byte $3B,%01000100 + !byte $3B,%01100100 + !byte $39,%00000101 + !byte $39,%00100101 + !byte $37,%10000101 + !byte $37,%10100101 + !byte $35,%00000110 + !byte $35,%00100110 + !byte $33,%01100110 + !byte $33,%10000110 + !byte $31,%11000110 + !byte $31,%00000111 + !byte $2F,%01000111 + !byte $2D,%10000111 + !byte $2B,%11000111 + !byte $2B,%00001000 + !byte $29,%00101000 + !byte $29,%01001000 + !byte $27,%01101000 + !byte $25,%10101000 + !byte $23,%11001000 + !byte $23,%00001001 + !byte $21,%00101001 + !byte $1F,%01001001 + !byte $1D,%01101001 + !byte $1B,%10001001 + !byte $1B,%10101001 + !byte $19,%10101001 + !byte $19,%11001001 + !byte $17,%11001001 + !byte $15,%00001010 + !byte $13,%00101010 + !byte $11,%01001010 + !byte $0F,%01001010 + !byte $0D,%01101010 + !byte $0B,%01101010 + !byte $09,%10001010 + !byte $07,%10001010 + !byte $05,%10001010 + !byte $03,%10001010 + !byte $01,%10001010 + !byte $3F,%01100001 + !byte $3F,%10000001 + !byte $3F,%10100001 + !byte $3F,%11000001 + !byte $3F,%00000010 + !byte $3F,%00100010 + !byte $3D,%00000011 + !byte $3D,%00100011 + !byte $3D,%01000011 + !byte $3B,%11000011 + !byte $3B,%00000100 + !byte $3B,%00100100 + !byte $39,%10000100 + !byte $39,%10100100 + !byte $39,%11000100 + !byte $37,%01000101 + !byte $37,%01100101 + !byte $35,%11000101 + !byte $33,%01000110 + !byte $31,%10100110 + !byte $2F,%00000111 + !byte $2F,%00100111 + !byte $2D,%01100111 + !byte $2B,%10100111 + !byte $29,%00001000 + !byte $27,%01001000 + !byte $25,%10001000 + !byte $23,%10101000 + !byte $21,%00001001 + !byte $1F,%00101001 + !byte $1D,%01001001 + !byte $1B,%01101001 + !byte $19,%10001001 + !byte $17,%10101001 + !byte $15,%11001001 + !byte $13,%00001010 + !byte $11,%00101010 + !byte $0F,%00101010 + !byte $0D,%01001010 + !byte $0B,%01001010 + !byte $09,%01101010 + !byte $07,%01101010 + !byte $05,%01101010 + !byte $03,%01101010 + !byte $01,%01101010 + !byte $3F,%00000000 + !byte $3F,%00100000 + !byte $3F,%01000000 + !byte $3F,%01100000 + !byte $3F,%10000000 + !byte $3F,%10100000 + !byte $3F,%11000000 + !byte $3F,%00000001 + !byte $3F,%00100001 + !byte $3F,%01000001 + !byte $3D,%01100010 + !byte $3D,%10000010 + !byte $3D,%10100010 + !byte $3D,%11000010 + !byte $3B,%10000011 + !byte $3B,%10100011 + !byte $39,%01000100 + !byte $39,%01100100 + !byte $37,%00000101 + !byte $37,%00100101 + !byte $35,%10000101 + !byte $35,%10100101 + !byte $33,%00000110 + !byte $33,%00100110 + !byte $31,%01100110 + !byte $31,%10000110 + !byte $2F,%11000110 + !byte $2D,%00100111 + !byte $2D,%01000111 + !byte $2B,%10000111 + !byte $29,%11000111 + !byte $27,%00101000 + !byte $25,%01001000 + !byte $25,%01101000 + !byte $23,%10001000 + !byte $21,%10101000 + !byte $21,%11001000 + !byte $1F,%00001001 + !byte $1D,%00101001 + !byte $1B,%01001001 + !byte $19,%01101001 + !byte $17,%10001001 + !byte $15,%10101001 + !byte $13,%11001001 + !byte $11,%00001010 + !byte $0F,%00001010 + !byte $0D,%00101010 + !byte $0B,%00101010 + !byte $09,%01001010 + !byte $07,%01001010 + !byte $05,%01001010 + !byte $03,%01001010 + !byte $01,%01001010 + !byte $3D,%10100001 + !byte $3D,%11000001 + !byte $3D,%00000010 + !byte $3D,%00100010 + !byte $3D,%01000010 + !byte $3B,%00100011 + !byte $3B,%01000011 + !byte $3B,%01100011 + !byte $39,%00000100 + !byte $39,%00100100 + !byte $37,%10100100 + !byte $37,%11000100 + !byte $35,%01000101 + !byte $35,%01100101 + !byte $33,%10100101 + !byte $33,%11000101 + !byte $31,%00100110 + !byte $31,%01000110 + !byte $2F,%10000110 + !byte $2F,%10100110 + !byte $2D,%00000111 + !byte $2B,%01000111 + !byte $2B,%01100111 + !byte $29,%10000111 + !byte $29,%10100111 + !byte $27,%11000111 + !byte $27,%00001000 + !byte $25,%00101000 + !byte $23,%01101000 + !byte $21,%10001000 + !byte $1F,%11001000 + !byte $1D,%00001001 + !byte $1B,%00101001 + !byte $19,%01001001 + !byte $17,%01101001 + !byte $15,%10001001 + !byte $13,%10101001 + !byte $11,%11001001 + !byte $0F,%11001001 + !byte $0D,%00001010 + !byte $0B,%00001010 + !byte $09,%00101010 + !byte $07,%00101010 + !byte $05,%00101010 + !byte $03,%00101010 + !byte $01,%00101010 + !byte $3D,%01100000 + !byte $3D,%10000000 + !byte $3D,%10100000 + !byte $3D,%11000000 + !byte $3D,%00000001 + !byte $3D,%00100001 + !byte $3D,%01000001 + !byte $3D,%01100001 + !byte $3D,%10000001 + !byte $3B,%10000010 + !byte $3B,%10100010 + !byte $3B,%11000010 + !byte $3B,%00000011 + !byte $39,%10000011 + !byte $39,%10100011 + !byte $39,%11000011 + !byte $37,%01000100 + !byte $37,%01100100 + !byte $37,%10000100 + !byte $35,%00000101 + !byte $35,%00100101 + !byte $33,%01100101 + !byte $33,%10000101 + !byte $31,%00000110 + !byte $2F,%01100110 + !byte $2D,%10100110 + !byte $2D,%11000110 + !byte $2B,%00100111 + !byte $29,%01100111 + !byte $27,%10100111 + !byte $25,%00001000 + !byte $23,%01001000 + !byte $21,%01101000 + !byte $1F,%10101000 + !byte $1D,%11001000 + !byte $1B,%00001001 + !byte $19,%00101001 + !byte $17,%01001001 + !byte $15,%01101001 + !byte $13,%10001001 + !byte $11,%10101001 + !byte $0F,%10101001 + !byte $0D,%11001001 + !byte $0B,%11001001 + !byte $09,%00001010 + !byte $07,%00001010 + !byte $05,%00001010 + !byte $03,%00001010 + !byte $01,%00001010 + !byte $3D,%00000000 + !byte $3D,%00100000 + !byte $3D,%01000000 + !byte $3B,%11000001 + !byte $3B,%00000010 + !byte $3B,%00100010 + !byte $3B,%01000010 + !byte $3B,%01100010 + !byte $39,%00100011 + !byte $39,%01000011 + !byte $39,%01100011 + !byte $37,%00000100 + !byte $37,%00100100 + !byte $35,%10000100 + !byte $35,%10100100 + !byte $35,%11000100 + !byte $33,%01000101 + !byte $31,%10100101 + !byte $31,%11000101 + !byte $2F,%00100110 + !byte $2F,%01000110 + !byte $2D,%10000110 + !byte $2B,%11000110 + !byte $2B,%00000111 + !byte $29,%01000111 + !byte $27,%10000111 + !byte $25,%11000111 + !byte $23,%00001000 + !byte $23,%00101000 + !byte $21,%01001000 + !byte $1F,%01101000 + !byte $1F,%10001000 + !byte $1D,%10101000 + !byte $1B,%11001000 + !byte $19,%00001001 + !byte $17,%00101001 + !byte $15,%01001001 + !byte $13,%01101001 + !byte $11,%10001001 + !byte $0F,%10001001 + !byte $0D,%10101001 + !byte $0B,%10101001 + !byte $09,%11001001 + !byte $07,%11001001 + !byte $05,%11001001 + !byte $03,%11001001 + !byte $01,%11001001 + !byte $3B,%00000001 + !byte $3B,%00100001 + !byte $3B,%01000001 + !byte $3B,%01100001 + !byte $3B,%10000001 + !byte $3B,%10100001 + !byte $39,%10000010 + !byte $39,%10100010 + !byte $39,%11000010 + !byte $39,%00000011 + !byte $37,%10000011 + !byte $37,%10100011 + !byte $37,%11000011 + !byte $35,%01000100 + !byte $35,%01100100 + !byte $33,%00000101 + !byte $33,%00100101 + !byte $31,%01100101 + !byte $31,%10000101 + !byte $2F,%11000101 + !byte $2F,%00000110 + !byte $2D,%01000110 + !byte $2D,%01100110 + !byte $2B,%10100110 + !byte $29,%00000111 + !byte $29,%00100111 + !byte $27,%01000111 + !byte $27,%01100111 + !byte $25,%10000111 + !byte $25,%10100111 + !byte $23,%11000111 + !byte $21,%00101000 + !byte $1F,%01001000 + !byte $1D,%10001000 + !byte $1B,%10101000 + !byte $19,%11001000 + !byte $17,%00001001 + !byte $15,%00101001 + !byte $13,%01001001 + !byte $11,%01001001 + !byte $11,%01101001 + !byte $0F,%01101001 + !byte $0D,%10001001 + !byte $0B,%10001001 + !byte $09,%10101001 + !byte $07,%10101001 + !byte $05,%10101001 + !byte $03,%10101001 + !byte $01,%10101001 + !byte $3B,%00000000 + !byte $3B,%00100000 + !byte $3B,%01000000 + !byte $3B,%01100000 + !byte $3B,%10000000 + !byte $3B,%10100000 + !byte $3B,%11000000 + !byte $39,%00100010 + !byte $39,%01000010 + !byte $39,%01100010 + !byte $37,%00100011 + !byte $37,%01000011 + !byte $37,%01100011 + !byte $35,%00000100 + !byte $35,%00100100 + !byte $33,%10100100 + !byte $33,%11000100 + !byte $31,%00100101 + !byte $31,%01000101 + !byte $2F,%10100101 + !byte $2D,%00100110 + !byte $2B,%01100110 + !byte $2B,%10000110 + !byte $29,%11000110 + !byte $27,%00100111 + !byte $25,%01100111 + !byte $23,%10100111 + !byte $21,%00001000 + !byte $1F,%00101000 + !byte $1D,%01001000 + !byte $1D,%01101000 + !byte $1B,%10001000 + !byte $19,%10101000 + !byte $17,%11001000 + !byte $15,%00001001 + !byte $13,%00101001 + !byte $11,%00101001 + !byte $0F,%01001001 + !byte $0D,%01101001 + !byte $0B,%01101001 + !byte $09,%10001001 + !byte $07,%10001001 + !byte $05,%10001001 + !byte $03,%10001001 + !byte $01,%10001001 + !byte $39,%01000001 + !byte $39,%01100001 + !byte $39,%10000001 + !byte $39,%10100001 + !byte $39,%11000001 + !byte $39,%00000010 + !byte $37,%10100010 + !byte $37,%11000010 + !byte $37,%00000011 + !byte $35,%10100011 + !byte $35,%11000011 + !byte $33,%01000100 + !byte $33,%01100100 + !byte $33,%10000100 + !byte $31,%00000101 + !byte $2F,%01100101 + !byte $2F,%10000101 + !byte $2D,%11000101 + !byte $2D,%00000110 + !byte $2B,%01000110 + !byte $29,%10000110 + !byte $29,%10100110 + !byte $27,%00000111 + !byte $25,%01000111 + !byte $23,%01100111 + !byte $23,%10000111 + !byte $21,%10100111 + !byte $21,%11000111 + !byte $1F,%00001000 + !byte $1D,%00101000 + !byte $1B,%01001000 + !byte $1B,%01101000 + !byte $19,%10001000 + !byte $17,%10101000 + !byte $15,%11001000 + !byte $13,%00001001 + !byte $11,%00001001 + !byte $0F,%00101001 + !byte $0D,%01001001 + !byte $0B,%01001001 + !byte $09,%01101001 + !byte $07,%01101001 + !byte $05,%01101001 + !byte $03,%01101001 + !byte $01,%01101001 + !byte $39,%00000000 + !byte $39,%00100000 + !byte $39,%01000000 + !byte $39,%01100000 + !byte $39,%10000000 + !byte $39,%10100000 + !byte $39,%11000000 + !byte $39,%00000001 + !byte $39,%00100001 + !byte $37,%01000010 + !byte $37,%01100010 + !byte $37,%10000010 + !byte $35,%01000011 + !byte $35,%01100011 + !byte $35,%10000011 + !byte $33,%00000100 + !byte $33,%00100100 + !byte $31,%10100100 + !byte $31,%11000100 + !byte $2F,%00100101 + !byte $2F,%01000101 + !byte $2D,%10100101 + !byte $2B,%00000110 + !byte $2B,%00100110 + !byte $29,%01100110 + !byte $27,%10100110 + !byte $27,%11000110 + !byte $25,%00000111 + !byte $25,%00100111 + !byte $23,%01000111 + !byte $21,%10000111 + !byte $1F,%11000111 + !byte $1D,%00001000 + !byte $1B,%00101000 + !byte $19,%01101000 + !byte $17,%10001000 + !byte $15,%10101000 + !byte $13,%11001000 + !byte $11,%11001000 + !byte $0F,%00001001 + !byte $0D,%00101001 + !byte $0B,%00101001 + !byte $09,%01001001 + !byte $07,%01001001 + !byte $05,%01001001 + !byte $03,%01001001 + !byte $01,%01001001 + !byte $37,%10000001 + !byte $37,%10100001 + !byte $37,%11000001 + !byte $37,%00000010 + !byte $37,%00100010 + !byte $35,%11000010 + !byte $35,%00000011 + !byte $35,%00100011 + !byte $33,%10100011 + !byte $33,%11000011 + !byte $31,%01100100 + !byte $31,%10000100 + !byte $2F,%11000100 + !byte $2F,%00000101 + !byte $2D,%01100101 + !byte $2D,%10000101 + !byte $2B,%11000101 + !byte $29,%00100110 + !byte $29,%01000110 + !byte $27,%10000110 + !byte $25,%11000110 + !byte $23,%00100111 + !byte $21,%01100111 + !byte $1F,%10000111 + !byte $1F,%10100111 + !byte $1D,%11000111 + !byte $1B,%00001000 + !byte $19,%00101000 + !byte $19,%01001000 + !byte $17,%01101000 + !byte $15,%10001000 + !byte $13,%10001000 + !byte $13,%10101000 + !byte $11,%10101000 + !byte $0F,%11001000 + !byte $0D,%00001001 + !byte $0B,%00001001 + !byte $09,%00101001 + !byte $07,%00101001 + !byte $05,%00101001 + !byte $03,%00101001 + !byte $01,%00101001 + !byte $37,%00000000 + !byte $37,%00100000 + !byte $37,%01000000 + !byte $37,%01100000 + !byte $37,%10000000 + !byte $37,%10100000 + !byte $37,%11000000 + !byte $37,%00000001 + !byte $37,%00100001 + !byte $37,%01000001 + !byte $37,%01100001 + !byte $35,%01100010 + !byte $35,%10000010 + !byte $35,%10100010 + !byte $33,%01000011 + !byte $33,%01100011 + !byte $33,%10000011 + !byte $31,%00000100 + !byte $31,%00100100 + !byte $31,%01000100 + !byte $2F,%10000100 + !byte $2F,%10100100 + !byte $2D,%00100101 + !byte $2D,%01000101 + !byte $2B,%10000101 + !byte $2B,%10100101 + !byte $29,%00000110 + !byte $27,%01000110 + !byte $27,%01100110 + !byte $25,%10100110 + !byte $23,%00000111 + !byte $21,%00100111 + !byte $21,%01000111 + !byte $1F,%01100111 + !byte $1D,%10100111 + !byte $1B,%11000111 + !byte $19,%00001000 + !byte $17,%00101000 + !byte $17,%01001000 + !byte $15,%01001000 + !byte $15,%01101000 + !byte $13,%01101000 + !byte $11,%10001000 + !byte $0F,%10101000 + !byte $0D,%11001000 + !byte $0B,%11001000 + !byte $09,%00001001 + !byte $07,%00001001 + !byte $05,%00001001 + !byte $03,%00001001 + !byte $01,%00001001 + !byte $35,%10100001 + !byte $35,%11000001 + !byte $35,%00000010 + !byte $35,%00100010 + !byte $35,%01000010 + !byte $33,%00000011 + !byte $33,%00100011 + !byte $31,%10100011 + !byte $31,%11000011 + !byte $2F,%01100100 + !byte $2D,%11000100 + !byte $2D,%00000101 + !byte $2B,%01100101 + !byte $29,%11000101 + !byte $27,%00100110 + !byte $25,%01100110 + !byte $25,%10000110 + !byte $23,%10100110 + !byte $23,%11000110 + !byte $21,%00000111 + !byte $1F,%01000111 + !byte $1D,%10000111 + !byte $1B,%10100111 + !byte $19,%11000111 + !byte $17,%00001000 + !byte $15,%00101000 + !byte $13,%01001000 + !byte $11,%01101000 + !byte $0F,%10001000 + !byte $0D,%10101000 + !byte $0B,%10101000 + !byte $09,%11001000 + !byte $07,%11001000 + !byte $05,%11001000 + !byte $03,%11001000 + !byte $01,%11001000 + !byte $35,%10100000 + !byte $35,%11000000 + !byte $35,%00000001 + !byte $35,%00100001 + !byte $35,%01000001 + !byte $35,%01100001 + !byte $35,%10000001 + !byte $33,%01100010 + !byte $33,%10000010 + !byte $33,%10100010 + !byte $33,%11000010 + !byte $31,%01100011 + !byte $31,%10000011 + !byte $2F,%00100100 + !byte $2F,%01000100 + !byte $2D,%10100100 + !byte $2B,%00100101 + !byte $2B,%01000101 + !byte $29,%10000101 + !byte $29,%10100101 + !byte $27,%00000110 + !byte $25,%01000110 + !byte $23,%10000110 + !byte $21,%11000110 + !byte $1F,%00100111 + !byte $1D,%01000111 + !byte $1D,%01100111 + !byte $1B,%10000111 + !byte $19,%10100111 + !byte $17,%11000111 + !byte $15,%00001000 + !byte $13,%00101000 + !byte $11,%01001000 + !byte $0F,%01101000 + !byte $0D,%10001000 + !byte $0B,%10001000 + !byte $09,%10101000 + !byte $07,%10101000 + !byte $05,%10101000 + !byte $03,%10101000 + !byte $01,%10101000 + !byte $35,%00000000 + !byte $35,%00100000 + !byte $35,%01000000 + !byte $35,%01100000 + !byte $35,%10000000 + !byte $33,%11000001 + !byte $33,%00000010 + !byte $33,%00100010 + !byte $33,%01000010 + !byte $31,%00000011 + !byte $31,%00100011 + !byte $31,%01000011 + !byte $2F,%10100011 + !byte $2F,%11000011 + !byte $2F,%00000100 + !byte $2D,%01100100 + !byte $2D,%10000100 + !byte $2B,%11000100 + !byte $2B,%00000101 + !byte $29,%01000101 + !byte $29,%01100101 + !byte $27,%10100101 + !byte $27,%11000101 + !byte $25,%00100110 + !byte $23,%01100110 + !byte $21,%10100110 + !byte $1F,%00000111 + !byte $1D,%00100111 + !byte $1B,%01100111 + !byte $19,%10000111 + !byte $17,%10100111 + !byte $15,%11000111 + !byte $13,%00001000 + !byte $11,%00101000 + !byte $0F,%01001000 + !byte $0D,%01001000 + !byte $0D,%01101000 + !byte $0B,%01101000 + !byte $09,%10001000 + !byte $07,%10001000 + !byte $05,%10001000 + !byte $03,%10001000 + !byte $01,%10001000 + !byte $33,%00100001 + !byte $33,%01000001 + !byte $33,%01100001 + !byte $33,%10000001 + !byte $33,%10100001 + !byte $31,%10000010 + !byte $31,%10100010 + !byte $31,%11000010 + !byte $2F,%01100011 + !byte $2F,%10000011 + !byte $2D,%00000100 + !byte $2D,%00100100 + !byte $2D,%01000100 + !byte $2B,%10100100 + !byte $29,%00100101 + !byte $27,%10000101 + !byte $25,%11000101 + !byte $25,%00000110 + !byte $23,%00100110 + !byte $23,%01000110 + !byte $21,%01100110 + !byte $21,%10000110 + !byte $1F,%10100110 + !byte $1F,%11000110 + !byte $1D,%00000111 + !byte $1B,%00100111 + !byte $1B,%01000111 + !byte $19,%01100111 + !byte $17,%10000111 + !byte $15,%10100111 + !byte $13,%11000111 + !byte $11,%00001000 + !byte $0F,%00101000 + !byte $0D,%00101000 + !byte $0B,%01001000 + !byte $09,%01001000 + !byte $09,%01101000 + !byte $07,%01101000 + !byte $05,%01101000 + !byte $03,%01101000 + !byte $01,%01101000 + !byte $33,%00000000 + !byte $33,%00100000 + !byte $33,%01000000 + !byte $33,%01100000 + !byte $33,%10000000 + !byte $33,%10100000 + !byte $33,%11000000 + !byte $33,%00000001 + !byte $31,%00000010 + !byte $31,%00100010 + !byte $31,%01000010 + !byte $31,%01100010 + !byte $2F,%00000011 + !byte $2F,%00100011 + !byte $2F,%01000011 + !byte $2D,%11000011 + !byte $2B,%01100100 + !byte $2B,%10000100 + !byte $29,%11000100 + !byte $29,%00000101 + !byte $27,%01000101 + !byte $27,%01100101 + !byte $25,%10100101 + !byte $23,%00000110 + !byte $21,%01000110 + !byte $1F,%10000110 + !byte $1D,%11000110 + !byte $1B,%00000111 + !byte $19,%01000111 + !byte $17,%01100111 + !byte $15,%10000111 + !byte $13,%10100111 + !byte $11,%11000111 + !byte $0F,%00001000 + !byte $0D,%00001000 + !byte $0B,%00101000 + !byte $09,%00101000 + !byte $07,%01001000 + !byte $05,%01001000 + !byte $03,%01001000 + !byte $01,%01001000 + !byte $31,%01100001 + !byte $31,%10000001 + !byte $31,%10100001 + !byte $31,%11000001 + !byte $2F,%10000010 + !byte $2F,%10100010 + !byte $2F,%11000010 + !byte $2D,%01100011 + !byte $2D,%10000011 + !byte $2D,%10100011 + !byte $2B,%00100100 + !byte $2B,%01000100 + !byte $29,%10000100 + !byte $29,%10100100 + !byte $27,%00000101 + !byte $27,%00100101 + !byte $25,%01100101 + !byte $25,%10000101 + !byte $23,%11000101 + !byte $21,%00100110 + !byte $1F,%01100110 + !byte $1D,%10100110 + !byte $1B,%11000110 + !byte $19,%00000111 + !byte $19,%00100111 + !byte $17,%01000111 + !byte $15,%01100111 + !byte $13,%10000111 + !byte $11,%10100111 + !byte $0F,%11000111 + !byte $0D,%11000111 + !byte $0B,%00001000 + !byte $09,%00001000 + !byte $07,%00101000 + !byte $05,%00101000 + !byte $03,%00101000 + !byte $01,%00101000 + !byte $31,%00000000 + !byte $31,%00100000 + !byte $31,%01000000 + !byte $31,%01100000 + !byte $31,%10000000 + !byte $31,%10100000 + !byte $31,%11000000 + !byte $31,%00000001 + !byte $31,%00100001 + !byte $31,%01000001 + !byte $2F,%00100010 + !byte $2F,%01000010 + !byte $2F,%01100010 + !byte $2D,%00100011 + !byte $2D,%01000011 + !byte $2B,%10100011 + !byte $2B,%11000011 + !byte $2B,%00000100 + !byte $29,%01100100 + !byte $27,%11000100 + !byte $25,%01000101 + !byte $23,%10000101 + !byte $23,%10100101 + !byte $21,%11000101 + !byte $21,%00000110 + !byte $1F,%00100110 + !byte $1F,%01000110 + !byte $1D,%01100110 + !byte $1D,%10000110 + !byte $1B,%10100110 + !byte $19,%11000110 + !byte $17,%00100111 + !byte $15,%01000111 + !byte $13,%01100111 + !byte $11,%10000111 + !byte $0F,%10100111 + !byte $0D,%10100111 + !byte $0B,%11000111 + !byte $09,%11000111 + !byte $07,%00001000 + !byte $05,%00001000 + !byte $03,%00001000 + !byte $01,%00001000 + !byte $2F,%10000001 + !byte $2F,%10100001 + !byte $2F,%11000001 + !byte $2F,%00000010 + !byte $2D,%10100010 + !byte $2D,%11000010 + !byte $2D,%00000011 + !byte $2B,%01100011 + !byte $2B,%10000011 + !byte $29,%00100100 + !byte $29,%01000100 + !byte $27,%10000100 + !byte $27,%10100100 + !byte $25,%00000101 + !byte $25,%00100101 + !byte $23,%01100101 + !byte $21,%10100101 + !byte $1F,%00000110 + !byte $1D,%01000110 + !byte $1B,%10000110 + !byte $19,%10100110 + !byte $17,%11000110 + !byte $17,%00000111 + !byte $15,%00100111 + !byte $13,%01000111 + !byte $11,%01100111 + !byte $0F,%10000111 + !byte $0D,%10000111 + !byte $0B,%10100111 + !byte $09,%10100111 + !byte $07,%11000111 + !byte $05,%11000111 + !byte $03,%11000111 + !byte $01,%11000111 + !byte $2F,%10000000 + !byte $2F,%10100000 + !byte $2F,%11000000 + !byte $2F,%00000001 + !byte $2F,%00100001 + !byte $2F,%01000001 + !byte $2F,%01100001 + !byte $2D,%01000010 + !byte $2D,%01100010 + !byte $2D,%10000010 + !byte $2B,%00100011 + !byte $2B,%01000011 + !byte $29,%11000011 + !byte $29,%00000100 + !byte $27,%01000100 + !byte $27,%01100100 + !byte $25,%10100100 + !byte $25,%11000100 + !byte $23,%00100101 + !byte $23,%01000101 + !byte $21,%10000101 + !byte $1F,%11000101 + !byte $1D,%00100110 + !byte $1B,%01000110 + !byte $1B,%01100110 + !byte $19,%10000110 + !byte $17,%10100110 + !byte $15,%00000111 + !byte $13,%00100111 + !byte $11,%01000111 + !byte $0F,%01000111 + !byte $0F,%01100111 + !byte $0D,%01100111 + !byte $0B,%10000111 + !byte $09,%10000111 + !byte $07,%10100111 + !byte $05,%10100111 + !byte $03,%10100111 + !byte $01,%10100111 + !byte $2F,%00000000 + !byte $2F,%00100000 + !byte $2F,%01000000 + !byte $2F,%01100000 + !byte $2D,%10100001 + !byte $2D,%11000001 + !byte $2D,%00000010 + !byte $2D,%00100010 + !byte $2B,%11000010 + !byte $2B,%00000011 + !byte $29,%01100011 + !byte $29,%10000011 + !byte $29,%10100011 + !byte $27,%00000100 + !byte $27,%00100100 + !byte $25,%10000100 + !byte $23,%00000101 + !byte $21,%01000101 + !byte $21,%01100101 + !byte $1F,%10100101 + !byte $1D,%11000101 + !byte $1D,%00000110 + !byte $1B,%00100110 + !byte $19,%01100110 + !byte $17,%10000110 + !byte $15,%10100110 + !byte $15,%11000110 + !byte $13,%00000111 + !byte $11,%00100111 + !byte $0F,%00100111 + !byte $0D,%01000111 + !byte $0B,%01100111 + !byte $09,%01100111 + !byte $07,%10000111 + !byte $05,%10000111 + !byte $03,%10000111 + !byte $01,%10000111 + !byte $2D,%11000000 + !byte $2D,%00000001 + !byte $2D,%00100001 + !byte $2D,%01000001 + !byte $2D,%01100001 + !byte $2D,%10000001 + !byte $2B,%01100010 + !byte $2B,%10000010 + !byte $2B,%10100010 + !byte $29,%00100011 + !byte $29,%01000011 + !byte $27,%11000011 + !byte $25,%01000100 + !byte $25,%01100100 + !byte $23,%10100100 + !byte $23,%11000100 + !byte $21,%00100101 + !byte $1F,%01100101 + !byte $1F,%10000101 + !byte $1D,%10100101 + !byte $1B,%00000110 + !byte $19,%01000110 + !byte $17,%01100110 + !byte $15,%10000110 + !byte $13,%10100110 + !byte $13,%11000110 + !byte $11,%11000110 + !byte $11,%00000111 + !byte $0F,%00000111 + !byte $0D,%00100111 + !byte $0B,%01000111 + !byte $09,%01000111 + !byte $07,%01100111 + !byte $05,%01100111 + !byte $03,%01100111 + !byte $01,%01100111 + !byte $2D,%00000000 + !byte $2D,%00100000 + !byte $2D,%01000000 + !byte $2D,%01100000 + !byte $2D,%10000000 + !byte $2D,%10100000 + !byte $2B,%11000001 + !byte $2B,%00000010 + !byte $2B,%00100010 + !byte $2B,%01000010 + !byte $29,%11000010 + !byte $29,%00000011 + !byte $27,%10000011 + !byte $27,%10100011 + !byte $25,%00000100 + !byte $25,%00100100 + !byte $23,%01100100 + !byte $23,%10000100 + !byte $21,%11000100 + !byte $21,%00000101 + !byte $1F,%01000101 + !byte $1D,%10000101 + !byte $1B,%11000101 + !byte $19,%00000110 + !byte $19,%00100110 + !byte $17,%01000110 + !byte $15,%01100110 + !byte $13,%10000110 + !byte $11,%10100110 + !byte $0F,%11000110 + !byte $0D,%00000111 + !byte $0B,%00100111 + !byte $09,%00100111 + !byte $07,%01000111 + !byte $05,%01000111 + !byte $03,%01000111 + !byte $01,%01000111 + !byte $2B,%00100001 + !byte $2B,%01000001 + !byte $2B,%01100001 + !byte $2B,%10000001 + !byte $2B,%10100001 + !byte $29,%01100010 + !byte $29,%10000010 + !byte $29,%10100010 + !byte $27,%00100011 + !byte $27,%01000011 + !byte $27,%01100011 + !byte $25,%10100011 + !byte $25,%11000011 + !byte $23,%01000100 + !byte $21,%10100100 + !byte $1F,%00000101 + !byte $1F,%00100101 + !byte $1D,%01100101 + !byte $1B,%10000101 + !byte $1B,%10100101 + !byte $19,%11000101 + !byte $17,%00100110 + !byte $15,%01000110 + !byte $13,%01100110 + !byte $11,%10000110 + !byte $0F,%10100110 + !byte $0D,%11000110 + !byte $0B,%00000111 + !byte $09,%00000111 + !byte $07,%00100111 + !byte $05,%00100111 + !byte $03,%00100111 + !byte $01,%00100111 + !byte $2B,%00000000 + !byte $2B,%00100000 + !byte $2B,%01000000 + !byte $2B,%01100000 + !byte $2B,%10000000 + !byte $2B,%10100000 + !byte $2B,%11000000 + !byte $2B,%00000001 + !byte $29,%00000010 + !byte $29,%00100010 + !byte $29,%01000010 + !byte $27,%11000010 + !byte $27,%00000011 + !byte $25,%10000011 + !byte $23,%00000100 + !byte $23,%00100100 + !byte $21,%01100100 + !byte $21,%10000100 + !byte $1F,%11000100 + !byte $1D,%00100101 + !byte $1D,%01000101 + !byte $1B,%01100101 + !byte $19,%10100101 + !byte $17,%11000101 + !byte $17,%00000110 + !byte $15,%00100110 + !byte $13,%01000110 + !byte $11,%01100110 + !byte $0F,%10000110 + !byte $0D,%10100110 + !byte $0B,%11000110 + !byte $09,%11000110 + !byte $07,%00000111 + !byte $05,%00000111 + !byte $03,%00000111 + !byte $01,%00000111 + !byte $29,%01100001 + !byte $29,%10000001 + !byte $29,%10100001 + !byte $29,%11000001 + !byte $27,%01100010 + !byte $27,%10000010 + !byte $27,%10100010 + !byte $25,%01000011 + !byte $25,%01100011 + !byte $23,%10100011 + !byte $23,%11000011 + !byte $21,%01000100 + !byte $1F,%10000100 + !byte $1F,%10100100 + !byte $1D,%00000101 + !byte $1B,%01000101 + !byte $19,%10000101 + !byte $17,%10100101 + !byte $15,%00000110 + !byte $13,%00100110 + !byte $11,%01000110 + !byte $0F,%01100110 + !byte $0D,%10000110 + !byte $0B,%10100110 + !byte $09,%10100110 + !byte $07,%11000110 + !byte $05,%11000110 + !byte $03,%11000110 + !byte $01,%11000110 + !byte $29,%01000000 + !byte $29,%01100000 + !byte $29,%10000000 + !byte $29,%10100000 + !byte $29,%11000000 + !byte $29,%00000001 + !byte $29,%00100001 + !byte $29,%01000001 + !byte $27,%00000010 + !byte $27,%00100010 + !byte $27,%01000010 + !byte $25,%11000010 + !byte $25,%00000011 + !byte $25,%00100011 + !byte $23,%01100011 + !byte $23,%10000011 + !byte $21,%00000100 + !byte $21,%00100100 + !byte $1F,%01100100 + !byte $1D,%10100100 + !byte $1D,%11000100 + !byte $1B,%00000101 + !byte $1B,%00100101 + !byte $19,%01000101 + !byte $19,%01100101 + !byte $17,%10000101 + !byte $15,%11000101 + !byte $13,%00000110 + !byte $11,%00100110 + !byte $0F,%01000110 + !byte $0D,%01100110 + !byte $0B,%10000110 + !byte $09,%10000110 + !byte $07,%10100110 + !byte $05,%10100110 + !byte $03,%10100110 + !byte $01,%10100110 + !byte $29,%00000000 + !byte $29,%00100000 + !byte $27,%10000001 + !byte $27,%10100001 + !byte $27,%11000001 + !byte $25,%10000010 + !byte $25,%10100010 + !byte $23,%00100011 + !byte $23,%01000011 + !byte $21,%10100011 + !byte $21,%11000011 + !byte $1F,%00100100 + !byte $1F,%01000100 + !byte $1D,%10000100 + !byte $1B,%11000100 + !byte $19,%00100101 + !byte $17,%01100101 + !byte $15,%10000101 + !byte $15,%10100101 + !byte $13,%11000101 + !byte $11,%00000110 + !byte $0F,%00100110 + !byte $0D,%01000110 + !byte $0B,%01100110 + !byte $09,%01100110 + !byte $07,%10000110 + !byte $05,%10000110 + !byte $03,%10000110 + !byte $01,%10000110 + !byte $27,%10100000 + !byte $27,%11000000 + !byte $27,%00000001 + !byte $27,%00100001 + !byte $27,%01000001 + !byte $27,%01100001 + !byte $25,%00100010 + !byte $25,%01000010 + !byte $25,%01100010 + !byte $23,%11000010 + !byte $23,%00000011 + !byte $21,%01100011 + !byte $21,%10000011 + !byte $1F,%00000100 + !byte $1D,%01100100 + !byte $1B,%10100100 + !byte $19,%00000101 + !byte $17,%01000101 + !byte $15,%01100101 + !byte $13,%10100101 + !byte $11,%11000101 + !byte $0F,%00000110 + !byte $0D,%00100110 + !byte $0B,%01000110 + !byte $09,%01000110 + !byte $07,%01100110 + !byte $05,%01100110 + !byte $03,%01100110 + !byte $01,%01100110 + !byte $27,%00000000 + !byte $27,%00100000 + !byte $27,%01000000 + !byte $27,%01100000 + !byte $27,%10000000 + !byte $25,%10100001 + !byte $25,%11000001 + !byte $25,%00000010 + !byte $23,%10000010 + !byte $23,%10100010 + !byte $21,%00100011 + !byte $21,%01000011 + !byte $1F,%10100011 + !byte $1F,%11000011 + !byte $1D,%00100100 + !byte $1D,%01000100 + !byte $1B,%01100100 + !byte $1B,%10000100 + !byte $19,%10100100 + !byte $19,%11000100 + !byte $17,%00000101 + !byte $17,%00100101 + !byte $15,%01000101 + !byte $13,%01100101 + !byte $13,%10000101 + !byte $11,%10100101 + !byte $0F,%11000101 + !byte $0D,%00000110 + !byte $0B,%00000110 + !byte $0B,%00100110 + !byte $09,%00100110 + !byte $07,%01000110 + !byte $05,%01000110 + !byte $03,%01000110 + !byte $01,%01000110 + !byte $25,%00000001 + !byte $25,%00100001 + !byte $25,%01000001 + !byte $25,%01100001 + !byte $25,%10000001 + !byte $23,%01000010 + !byte $23,%01100010 + !byte $21,%11000010 + !byte $21,%00000011 + !byte $1F,%01100011 + !byte $1F,%10000011 + !byte $1D,%11000011 + !byte $1D,%00000100 + !byte $1B,%01000100 + !byte $19,%10000100 + !byte $17,%11000100 + !byte $15,%00100101 + !byte $13,%01000101 + !byte $11,%10000101 + !byte $0F,%10100101 + !byte $0D,%11000101 + !byte $0B,%11000101 + !byte $09,%00000110 + !byte $07,%00100110 + !byte $05,%00100110 + !byte $03,%00100110 + !byte $01,%00100110 + !byte $25,%00000000 + !byte $25,%00100000 + !byte $25,%01000000 + !byte $25,%01100000 + !byte $25,%10000000 + !byte $25,%10100000 + !byte $25,%11000000 + !byte $23,%11000001 + !byte $23,%00000010 + !byte $23,%00100010 + !byte $21,%10000010 + !byte $21,%10100010 + !byte $1F,%01000011 + !byte $1D,%10100011 + !byte $1B,%00100100 + !byte $19,%01100100 + !byte $17,%10100100 + !byte $15,%00000101 + !byte $13,%00100101 + !byte $11,%01000101 + !byte $11,%01100101 + !byte $0F,%10000101 + !byte $0D,%10100101 + !byte $0B,%10100101 + !byte $09,%11000101 + !byte $07,%00000110 + !byte $05,%00000110 + !byte $03,%00000110 + !byte $01,%00000110 + !byte $23,%01000001 + !byte $23,%01100001 + !byte $23,%10000001 + !byte $23,%10100001 + !byte $21,%01000010 + !byte $21,%01100010 + !byte $1F,%00000011 + !byte $1F,%00100011 + !byte $1D,%01100011 + !byte $1D,%10000011 + !byte $1B,%11000011 + !byte $1B,%00000100 + !byte $19,%01000100 + !byte $17,%10000100 + !byte $15,%10100100 + !byte $15,%11000100 + !byte $13,%00000101 + !byte $11,%00100101 + !byte $0F,%01000101 + !byte $0F,%01100101 + !byte $0D,%01100101 + !byte $0D,%10000101 + !byte $0B,%10000101 + !byte $09,%10100101 + !byte $07,%11000101 + !byte $05,%11000101 + !byte $03,%11000101 + !byte $01,%11000101 + !byte $23,%00000000 + !byte $23,%00100000 + !byte $23,%01000000 + !byte $23,%01100000 + !byte $23,%10000000 + !byte $23,%10100000 + !byte $23,%11000000 + !byte $23,%00000001 + !byte $23,%00100001 + !byte $21,%11000001 + !byte $21,%00000010 + !byte $21,%00100010 + !byte $1F,%10000010 + !byte $1F,%10100010 + !byte $1F,%11000010 + !byte $1D,%00100011 + !byte $1D,%01000011 + !byte $1B,%10000011 + !byte $1B,%10100011 + !byte $19,%00000100 + !byte $19,%00100100 + !byte $17,%01000100 + !byte $17,%01100100 + !byte $15,%10000100 + !byte $13,%11000100 + !byte $11,%00000101 + !byte $0F,%00100101 + !byte $0D,%01000101 + !byte $0B,%01100101 + !byte $09,%10000101 + !byte $07,%10100101 + !byte $05,%10100101 + !byte $03,%10100101 + !byte $01,%10100101 + !byte $21,%01100001 + !byte $21,%10000001 + !byte $21,%10100001 + !byte $1F,%01000010 + !byte $1F,%01100010 + !byte $1D,%11000010 + !byte $1D,%00000011 + !byte $1B,%01100011 + !byte $19,%11000011 + !byte $17,%00100100 + !byte $15,%01100100 + !byte $13,%10100100 + !byte $11,%11000100 + !byte $0F,%00000101 + !byte $0D,%00100101 + !byte $0B,%01000101 + !byte $09,%01100101 + !byte $07,%10000101 + !byte $05,%10000101 + !byte $03,%10000101 + !byte $01,%10000101 + !byte $21,%10000000 + !byte $21,%10100000 + !byte $21,%11000000 + !byte $21,%00000001 + !byte $21,%00100001 + !byte $21,%01000001 + !byte $1F,%11000001 + !byte $1F,%00000010 + !byte $1F,%00100010 + !byte $1D,%10100010 + !byte $1B,%00100011 + !byte $1B,%01000011 + !byte $19,%10000011 + !byte $19,%10100011 + !byte $17,%00000100 + !byte $15,%01000100 + !byte $13,%01100100 + !byte $13,%10000100 + !byte $11,%10100100 + !byte $0F,%11000100 + !byte $0D,%00000101 + !byte $0B,%00100101 + !byte $09,%01000101 + !byte $07,%01100101 + !byte $05,%01100101 + !byte $03,%01100101 + !byte $01,%01100101 + !byte $21,%00000000 + !byte $21,%00100000 + !byte $21,%01000000 + !byte $21,%01100000 + !byte $1F,%01100001 + !byte $1F,%10000001 + !byte $1F,%10100001 + !byte $1D,%01000010 + !byte $1D,%01100010 + !byte $1D,%10000010 + !byte $1B,%11000010 + !byte $1B,%00000011 + !byte $19,%01000011 + !byte $19,%01100011 + !byte $17,%10100011 + !byte $17,%11000011 + !byte $15,%00000100 + !byte $15,%00100100 + !byte $13,%01000100 + !byte $11,%10000100 + !byte $0F,%10100100 + !byte $0D,%11000100 + !byte $0B,%00000101 + !byte $09,%00100101 + !byte $07,%00100101 + !byte $07,%01000101 + !byte $05,%01000101 + !byte $03,%01000101 + !byte $01,%01000101 + !byte $1F,%11000000 + !byte $1F,%00000001 + !byte $1F,%00100001 + !byte $1F,%01000001 + !byte $1D,%00000010 + !byte $1D,%00100010 + !byte $1B,%10000010 + !byte $1B,%10100010 + !byte $19,%00100011 + !byte $17,%10000011 + !byte $15,%11000011 + !byte $13,%00100100 + !byte $11,%01000100 + !byte $11,%01100100 + !byte $0F,%10000100 + !byte $0D,%10100100 + !byte $0B,%11000100 + !byte $09,%00000101 + !byte $07,%00000101 + !byte $05,%00100101 + !byte $03,%00100101 + !byte $01,%00100101 + !byte $1F,%00000000 + !byte $1F,%00100000 + !byte $1F,%01000000 + !byte $1F,%01100000 + !byte $1F,%10000000 + !byte $1F,%10100000 + !byte $1D,%10000001 + !byte $1D,%10100001 + !byte $1D,%11000001 + !byte $1B,%01000010 + !byte $1B,%01100010 + !byte $19,%11000010 + !byte $19,%00000011 + !byte $17,%01000011 + !byte $17,%01100011 + !byte $15,%10000011 + !byte $15,%10100011 + !byte $13,%00000100 + !byte $11,%00100100 + !byte $0F,%01100100 + !byte $0D,%10000100 + !byte $0B,%10100100 + !byte $09,%11000100 + !byte $07,%11000100 + !byte $05,%00000101 + !byte $03,%00000101 + !byte $01,%00000101 + !byte $1D,%00000001 + !byte $1D,%00100001 + !byte $1D,%01000001 + !byte $1D,%01100001 + !byte $1B,%00000010 + !byte $1B,%00100010 + !byte $19,%10000010 + !byte $19,%10100010 + !byte $17,%00100011 + !byte $15,%01100011 + !byte $13,%10100011 + !byte $13,%11000011 + !byte $11,%00000100 + !byte $0F,%00100100 + !byte $0F,%01000100 + !byte $0D,%01100100 + !byte $0B,%10000100 + !byte $09,%10100100 + !byte $07,%10100100 + !byte $05,%11000100 + !byte $03,%11000100 + !byte $01,%11000100 + !byte $1D,%00000000 + !byte $1D,%00100000 + !byte $1D,%01000000 + !byte $1D,%01100000 + !byte $1D,%10000000 + !byte $1D,%10100000 + !byte $1D,%11000000 + !byte $1B,%10100001 + !byte $1B,%11000001 + !byte $19,%01000010 + !byte $19,%01100010 + !byte $17,%11000010 + !byte $17,%00000011 + !byte $15,%01000011 + !byte $13,%10000011 + !byte $11,%11000011 + !byte $0F,%00000100 + !byte $0D,%01000100 + !byte $0B,%01100100 + !byte $09,%10000100 + !byte $07,%10000100 + !byte $05,%10100100 + !byte $03,%10100100 + !byte $01,%10100100 + !byte $1B,%00100001 + !byte $1B,%01000001 + !byte $1B,%01100001 + !byte $1B,%10000001 + !byte $19,%00000010 + !byte $19,%00100010 + !byte $17,%10000010 + !byte $17,%10100010 + !byte $15,%00000011 + !byte $15,%00100011 + !byte $13,%01000011 + !byte $13,%01100011 + !byte $11,%10100011 + !byte $0F,%11000011 + !byte $0D,%00100100 + !byte $0B,%01000100 + !byte $09,%01100100 + !byte $07,%01100100 + !byte $05,%10000100 + !byte $03,%10000100 + !byte $01,%10000100 + !byte $1B,%01100000 + !byte $1B,%10000000 + !byte $1B,%10100000 + !byte $1B,%11000000 + !byte $1B,%00000001 + !byte $19,%10100001 + !byte $19,%11000001 + !byte $17,%01000010 + !byte $17,%01100010 + !byte $15,%11000010 + !byte $13,%00100011 + !byte $11,%01100011 + !byte $11,%10000011 + !byte $0F,%10100011 + !byte $0D,%11000011 + !byte $0D,%00000100 + !byte $0B,%00100100 + !byte $09,%01000100 + !byte $07,%01000100 + !byte $05,%01100100 + !byte $03,%01100100 + !byte $01,%01100100 + !byte $1B,%00000000 + !byte $1B,%00100000 + !byte $1B,%01000000 + !byte $19,%01000001 + !byte $19,%01100001 + !byte $19,%10000001 + !byte $17,%00000010 + !byte $17,%00100010 + !byte $15,%10000010 + !byte $15,%10100010 + !byte $13,%00000011 + !byte $11,%01000011 + !byte $0F,%10000011 + !byte $0D,%10100011 + !byte $0B,%00000100 + !byte $09,%00000100 + !byte $09,%00100100 + !byte $07,%00100100 + !byte $05,%01000100 + !byte $03,%01000100 + !byte $01,%01000100 + !byte $19,%10100000 + !byte $19,%11000000 + !byte $19,%00000001 + !byte $19,%00100001 + !byte $17,%10100001 + !byte $17,%11000001 + !byte $15,%01000010 + !byte $15,%01100010 + !byte $13,%10100010 + !byte $13,%11000010 + !byte $11,%00100011 + !byte $0F,%01000011 + !byte $0F,%01100011 + !byte $0D,%10000011 + !byte $0B,%10100011 + !byte $0B,%11000011 + !byte $09,%11000011 + !byte $07,%00000100 + !byte $05,%00100100 + !byte $03,%00100100 + !byte $01,%00100100 + !byte $19,%00000000 + !byte $19,%00100000 + !byte $19,%01000000 + !byte $19,%01100000 + !byte $19,%10000000 + !byte $17,%01000001 + !byte $17,%01100001 + !byte $17,%10000001 + !byte $15,%00000010 + !byte $15,%00100010 + !byte $13,%10000010 + !byte $11,%11000010 + !byte $11,%00000011 + !byte $0F,%00100011 + !byte $0D,%01100011 + !byte $0B,%10000011 + !byte $09,%10100011 + !byte $07,%11000011 + !byte $05,%00000100 + !byte $03,%00000100 + !byte $01,%00000100 + !byte $17,%11000000 + !byte $17,%00000001 + !byte $17,%00100001 + !byte $15,%10100001 + !byte $15,%11000001 + !byte $13,%01000010 + !byte $13,%01100010 + !byte $11,%10100010 + !byte $0F,%00000011 + !byte $0D,%01000011 + !byte $0B,%01100011 + !byte $09,%10000011 + !byte $07,%10100011 + !byte $05,%11000011 + !byte $03,%11000011 + !byte $01,%11000011 + !byte $17,%00000000 + !byte $17,%00100000 + !byte $17,%01000000 + !byte $17,%01100000 + !byte $17,%10000000 + !byte $17,%10100000 + !byte $15,%01100001 + !byte $15,%10000001 + !byte $13,%00000010 + !byte $13,%00100010 + !byte $11,%01100010 + !byte $11,%10000010 + !byte $0F,%11000010 + !byte $0D,%00000011 + !byte $0D,%00100011 + !byte $0B,%01000011 + !byte $09,%01100011 + !byte $07,%10000011 + !byte $05,%10100011 + !byte $03,%10100011 + !byte $01,%10100011 + !byte $15,%00000001 + !byte $15,%00100001 + !byte $15,%01000001 + !byte $13,%11000001 + !byte $11,%01000010 + !byte $0F,%10000010 + !byte $0F,%10100010 + !byte $0D,%11000010 + !byte $0B,%00100011 + !byte $09,%01000011 + !byte $07,%01100011 + !byte $05,%10000011 + !byte $03,%10000011 + !byte $01,%10000011 + !byte $15,%00100000 + !byte $15,%01000000 + !byte $15,%01100000 + !byte $15,%10000000 + !byte $15,%10100000 + !byte $15,%11000000 + !byte $13,%01100001 + !byte $13,%10000001 + !byte $13,%10100001 + !byte $11,%00000010 + !byte $11,%00100010 + !byte $0F,%01100010 + !byte $0D,%10100010 + !byte $0B,%00000011 + !byte $09,%00100011 + !byte $07,%01000011 + !byte $05,%01100011 + !byte $03,%01100011 + !byte $01,%01100011 + !byte $15,%00000000 + !byte $13,%00100001 + !byte $13,%01000001 + !byte $11,%10100001 + !byte $11,%11000001 + !byte $0F,%00100010 + !byte $0F,%01000010 + !byte $0D,%10000010 + !byte $0B,%10100010 + !byte $0B,%11000010 + !byte $09,%00000011 + !byte $07,%00100011 + !byte $05,%01000011 + !byte $03,%01000011 + !byte $01,%01000011 + !byte $13,%10000000 + !byte $13,%10100000 + !byte $13,%11000000 + !byte $13,%00000001 + !byte $11,%01100001 + !byte $11,%10000001 + !byte $0F,%00000010 + !byte $0D,%01000010 + !byte $0D,%01100010 + !byte $0B,%10000010 + !byte $09,%11000010 + !byte $07,%00000011 + !byte $05,%00100011 + !byte $03,%00100011 + !byte $01,%00100011 + !byte $13,%00000000 + !byte $13,%00100000 + !byte $13,%01000000 + !byte $13,%01100000 + !byte $11,%00100001 + !byte $11,%01000001 + !byte $0F,%10100001 + !byte $0F,%11000001 + !byte $0D,%00100010 + !byte $0B,%01100010 + !byte $09,%10100010 + !byte $07,%11000010 + !byte $05,%00000011 + !byte $03,%00000011 + !byte $01,%00000011 + !byte $11,%10100000 + !byte $11,%11000000 + !byte $11,%00000001 + !byte $0F,%01100001 + !byte $0F,%10000001 + !byte $0D,%11000001 + !byte $0D,%00000010 + !byte $0B,%01000010 + !byte $09,%01100010 + !byte $09,%10000010 + !byte $07,%10100010 + !byte $05,%11000010 + !byte $03,%11000010 + !byte $01,%11000010 + !byte $11,%00000000 + !byte $11,%00100000 + !byte $11,%01000000 + !byte $11,%01100000 + !byte $11,%10000000 + !byte $0F,%00100001 + !byte $0F,%01000001 + !byte $0D,%10100001 + !byte $0B,%00000010 + !byte $0B,%00100010 + !byte $09,%01000010 + !byte $07,%10000010 + !byte $05,%10000010 + !byte $05,%10100010 + !byte $03,%10100010 + !byte $01,%10100010 + !byte $0F,%10100000 + !byte $0F,%11000000 + !byte $0F,%00000001 + !byte $0D,%01100001 + !byte $0D,%10000001 + !byte $0B,%11000001 + !byte $09,%00100010 + !byte $07,%01000010 + !byte $07,%01100010 + !byte $05,%01100010 + !byte $03,%10000010 + !byte $01,%10000010 + !byte $0F,%00000000 + !byte $0F,%00100000 + !byte $0F,%01000000 + !byte $0F,%01100000 + !byte $0F,%10000000 + !byte $0D,%00100001 + !byte $0D,%01000001 + !byte $0B,%10100001 + !byte $09,%00000010 + !byte $07,%00100010 + !byte $05,%01000010 + !byte $03,%01100010 + !byte $01,%01100010 + !byte $0D,%11000000 + !byte $0D,%00000001 + !byte $0B,%01100001 + !byte $0B,%10000001 + !byte $09,%10100001 + !byte $09,%11000001 + !byte $07,%00000010 + !byte $05,%00100010 + !byte $03,%01000010 + !byte $01,%01000010 + !byte $0D,%01000000 + !byte $0D,%01100000 + !byte $0D,%10000000 + !byte $0D,%10100000 + !byte $0B,%00100001 + !byte $0B,%01000001 + !byte $09,%10000001 + !byte $07,%11000001 + !byte $05,%00000010 + !byte $03,%00100010 + !byte $01,%00100010 + !byte $0D,%00000000 + !byte $0D,%00100000 + !byte $0B,%11000000 + !byte $0B,%00000001 + !byte $09,%01100001 + !byte $07,%10100001 + !byte $05,%11000001 + !byte $03,%00000010 + !byte $01,%00000010 + !byte $0B,%10000000 + !byte $0B,%10100000 + !byte $09,%00100001 + !byte $09,%01000001 + !byte $07,%01100001 + !byte $07,%10000001 + !byte $05,%10100001 + !byte $03,%11000001 + !byte $01,%11000001 + !byte $0B,%00000000 + !byte $0B,%00100000 + !byte $0B,%01000000 + !byte $0B,%01100000 + !byte $09,%11000000 + !byte $09,%00000001 + !byte $07,%01000001 + !byte $05,%10000001 + !byte $03,%10100001 + !byte $01,%10100001 + !byte $09,%10000000 + !byte $09,%10100000 + !byte $07,%00100001 + !byte $05,%01100001 + !byte $03,%10000001 + !byte $01,%10000001 + !byte $09,%00000000 + !byte $09,%00100000 + !byte $09,%01000000 + !byte $09,%01100000 + !byte $07,%11000000 + !byte $07,%00000001 + !byte $05,%01000001 + !byte $03,%01100001 + !byte $01,%01100001 + !byte $07,%10000000 + !byte $07,%10100000 + !byte $05,%00000001 + !byte $05,%00100001 + !byte $03,%01000001 + !byte $01,%01000001 + !byte $07,%00100000 + !byte $07,%01000000 + !byte $07,%01100000 + !byte $05,%11000000 + !byte $03,%00100001 + !byte $01,%00100001 + !byte $07,%00000000 + !byte $05,%10000000 + !byte $05,%10100000 + !byte $03,%11000000 + !byte $03,%00000001 + !byte $01,%00000001 + !byte $05,%01000000 + !byte $05,%01100000 + !byte $03,%10100000 + !byte $01,%11000000 + !byte $05,%00000000 + !byte $05,%00100000 + !byte $03,%10000000 + !byte $01,%10100000 + !byte $03,%01000000 + !byte $03,%01100000 + !byte $01,%10000000 + !byte $03,%00000000 + !byte $03,%00100000 + !byte $01,%01100000 + !byte $01,%01000000 + !byte $01,%00000000 + !byte $01,%00100000 diff --git a/src/fx/fx.hgr.precomputed.1bit.a b/src/fx/fx.hgr.precomputed.1bit.a index 00ba0a828..771946512 100644 --- a/src/fx/fx.hgr.precomputed.1bit.a +++ b/src/fx/fx.hgr.precomputed.1bit.a @@ -136,7 +136,7 @@ hgr1himirror = $BF40 ; $C0 bytes +BUILD_HGR_MIRROR_LOOKUP_TABLES hgrlomirror, hgr1himirror +BUILD_MIRROR_COLS mirror_cols +BUILD_SPARSE_BITMASKS copymasks, mirror_copymasks - +LDAY .coords + +LDADDR .coords +STAY input jmp InputLoop Exit1Bit rts